private void StackDeepFirstSearch(int nodeNumber, LinkedList.LinkedList <T> visitedNodes)
{
IStack <int> stack = new ArrayStack <int>(_nodes.Count);
bool[] visited = new bool[_nodes.Count];
bool[] instack = new bool[_nodes.Count];
stack.Push(nodeNumber);
instack[nodeNumber] = true;
while (!stack.IsEmpty())
{
var n = stack.Pop();
visited[n] = true;
instack[n] = false;
visitedNodes.Insert(_nodes[n]);
foreach (var v in GetAdjacentVertices(n))
{
if (!visited[v] && !instack[v])
{
stack.Push(v);
instack[v] = true;
}
}
}
}
public void SortDescendingTests(int[] arr, int[] expectedArr)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
LinkedList.LinkedList expected = new LinkedList.LinkedList(expectedArr);
actual.SortDescending();
Assert.AreEqual(expected, actual);
}
public void ReverseTests(int[] arr, int[] expectedArr)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
LinkedList.LinkedList expected = new LinkedList.LinkedList(expectedArr);
actual.Reverse();
Assert.AreEqual(expected, actual);
}
public void AddTests(int[] arr, int[] expectedArr, int[] values)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
LinkedList.LinkedList expected = new LinkedList.LinkedList(expectedArr);
actual.Add(values);
Assert.AreEqual(expected, actual);
}
public void GetMinIndexTests(int[] arr, int expected)
{
LinkedList.LinkedList actualList = new LinkedList.LinkedList(arr);
int actual = actualList.GetMinIndex();
Assert.AreEqual(expected, actual);
}
public static void Main(string[] args)
{
try
{
XmlConfigurator.Configure();
Log.Info("Init list");
IList<int> list = new LinkedList.LinkedList<int>();
Log.Info("Add 50 item to list");
for (int i = 0; i < 50; i++)
{
Log.Info("Add value " + i);
list.Add(i);
}
var value = list[1];
Log.Info("value of item with index 1 is " + value);
Console.WriteLine(value);
}
catch (Exception exception)
{
Log.Error(exception.Message);
}
}
private void BreadthFirstSearch(LinkedList.LinkedList <T> visitedNodes)
{
IQueue <int> queue = new ArrayQueue <int>(_nodes.Count);
bool[] visited = new bool[_nodes.Count];
bool[] inqueue = new bool[_nodes.Count];
queue.Enqueue(0);
inqueue[0] = true;
while (!queue.IsEmpty())
{
var n = queue.Dequeue();
visited[n] = true;
inqueue[n] = false;
visitedNodes.Insert(_nodes[n]);
foreach (var v in GetAdjacentVertices(n))
{
if (!visited[v] && !inqueue[v])
{
queue.Enqueue(v);
inqueue[v] = true;
}
}
}
}
public static void Main(string[] args)
{
try
{
XmlConfigurator.Configure();
Log.Info("Init list");
IList <int> list = new LinkedList.LinkedList <int>();
Log.Info("Add 50 item to list");
for (int i = 0; i < 50; i++)
{
Log.Info("Add value " + i);
list.Add(i);
}
var value = list[1];
Log.Info("value of item with index 1 is " + value);
Console.WriteLine(value);
}
catch (Exception exception)
{
Log.Error(exception.Message);
}
}
public void DeleteByAllValueTests(int[] arr, int[] expectedArr, int value)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
LinkedList.LinkedList expected = new LinkedList.LinkedList(expectedArr);
actual.DeleteAllByValue(value);
Assert.AreEqual(expected, actual);
}
public void SetByIndexTests(int[] array, int index, int value, int[] expArray)
{
LinkedList.LinkedList expected = new LinkedList.LinkedList(expArray);
LinkedList.LinkedList actual = new LinkedList.LinkedList(array);
actual[index] = value;
Assert.AreEqual(expected, actual);
}
public void Remove_EmptyList_ShouldThrowException()
{
// Arrange
var list = new LinkedList.LinkedList<int>();
// Act
var element = list.Remove(0);
}
public IEnumerable <T> BreadthFirstSearch()
{
var visitedNodes = new LinkedList.LinkedList <T>();
BreadthFirstSearch(visitedNodes);
return(visitedNodes);
}
public IEnumerable <T> StackDeepFirstSearch()
{
var visitedNodes = new LinkedList.LinkedList <T>();
StackDeepFirstSearch(0, visitedNodes);
return(visitedNodes);
}
public void GetByIndexNegativeTests(int[] arr, int index)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
Assert.Throws <IndexOutOfRangeException>(() =>
{
var value = actual[index];
});
}
public void AddToIndexNegativeTests(int[] array, int index)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(array);
Assert.Throws <IndexOutOfRangeException>(() =>
{
actual.AddToIndex(index, 1);
});
}
public void GetByIndexTests(int[] array, int index, int expected)
{
LinkedList.LinkedList linkedList = new LinkedList.LinkedList(array);
int actual = linkedList[index];
Assert.AreEqual(expected, actual);
}
public void DeleteByIndexNegativeTests(int[] arr, int count)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
Assert.Throws <IndexOutOfRangeException>((() =>
{
actual.DeleteByIndex(count);
}));
}
public IEnumerable <T> DeepFirstSearch()
{
var visitedNodes = new LinkedList.LinkedList <T>();
var visited = new bool[_nodes.Count];
DeepFirstSearch(0, visitedNodes, visited);
return(visitedNodes);
}
public void AddToBeginTests(int[] array, int value, int[] expectedArr)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(array);
LinkedList.LinkedList expected = new LinkedList.LinkedList(expectedArr);
actual.AddToBegin(value);
Assert.AreEqual(expected, actual);
}
public UndirectedGraph(IReadOnlyList <T> nodes)
{
_vertices = new LinkedList.LinkedList <int> [nodes.Count];
for (var i = 0; i < _vertices.Length; i++)
{
_vertices[i] = new LinkedList.LinkedList <int>();
_nodes.Add(i, nodes[i]);
}
}
public void ReverseNegativeTests(int[] arr)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
Assert.Throws <NullReferenceException>(() =>
{
actual.Reverse();
});
}
public void AddToIndexTests(int[] array, int[] values, int index, int[] expectedArr)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(array);
LinkedList.LinkedList expected = new LinkedList.LinkedList(expectedArr);
actual.AddToIndex(index, values);
Assert.AreEqual(expected, actual);
}
public void DeleteByIndexTests(int index, int count, int[] expectedArr, int[] arr)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
LinkedList.LinkedList expected = new LinkedList.LinkedList(expectedArr);
actual.DeleteByIndex(index, count);
Assert.AreEqual(expected, actual);
}
public void DeleteFromBeginTests(int count, int[] expectedArr, int[] arr)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
LinkedList.LinkedList expected = new LinkedList.LinkedList(expectedArr);
actual.DeleteFromBegin(count);
Assert.AreEqual(expected, actual);
}
public void DeleteAllByValueNegativeTests(int[] arr)
{
LinkedList.LinkedList actual = new LinkedList.LinkedList(arr);
Assert.Throws <NullReferenceException>((() =>
{
actual.DeleteAllByValue(1);
}));
}
public LinkedList.LinkedList <T> Generate()
{
var visitedNodes = new LinkedList.LinkedList <T>();
var visited = new HashSet <int>();
DeepFirstSearch(0, visitedNodes, visited);
return(visitedNodes);
}
public void TestLinkedListUpperBoundary()
{
var linkedList = new LinkedList.LinkedList();
linkedList.AddLast(20);
linkedList.AddLast(21);
linkedList.AddLast(22);
var actual = linkedList.ElementFromTailAt(3).Value;
}
private void DeepFirstSearch(int nodeNumber, LinkedList.LinkedList <T> visitedNodes, HashSet <int> visited)
{
visited.Add(nodeNumber);
visitedNodes.Insert(_nodes[nodeNumber]);
var nextNode = GetRandomNode(visited);
if (!visited.Contains(nextNode))
{
DeepFirstSearch(nextNode, visitedNodes, visited);
}
}
private void DeepFirstSearch(int nodeNumber, LinkedList.LinkedList <T> visitedNodes, bool[] visited)
{
visited[nodeNumber] = true;
visitedNodes.Insert(_nodes[nodeNumber]);
foreach (var v in GetAdjacentVertices(nodeNumber))
{
if (!visited[v])
{
DeepFirstSearch(v, visitedNodes, visited);
}
}
}
private static ILinkedList <Entry <TKey, TValue> > GetBucket(TKey key, ILinkedList <Entry <TKey, TValue> >[] buckets)
{
var index = GetBucketIndex(key, buckets.Length);
var bucket = buckets[index];
if (bucket == null)
{
bucket = new LinkedList.LinkedList <Entry <TKey, TValue> >();
buckets[index] = bucket;
}
return(bucket);
}
public void GetFirstElementFromTail()
{
var linkedList = new LinkedList.LinkedList();
linkedList.AddLast(20);
linkedList.AddLast(21);
linkedList.AddLast(22);
var actual = linkedList.ElementFromTailAt(0).Value;
var expected = 22;
Assert.AreEqual(expected, actual);
}
public void Add_EmptyList_ShouldAddElement()
{
// Arrange
var list = new LinkedList.LinkedList<int>();
// Act
list.Add(5);
// Assert
Assert.AreEqual(1, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>(){ 5 });
}
static void Main(string[] args)
{
// Linked List Example
LinkedList.LinkedList <int> list = new LinkedList.LinkedList <int>();
list.push_back(123);
list.push_back(456);
list.push_back(789);
int i = 1;
foreach (int val in list)
{
Console.WriteLine($"{i}: {val}");
i += 1;
}
Console.WriteLine(list);
list.pop_back();
Console.WriteLine(list);
list.pop_back();
Console.WriteLine(list);
list.pop_back();
Console.WriteLine(list);
// Binary Tree Example
BinaryTree.BinaryTree <int, int> tree = new BinaryTree.BinaryTree <int, int>();
tree.insert(2, 123);
tree.insert(1, 456);
tree.insert(3, 789);
tree.remove(2);
tree.find(2);
tree.find(1);
tree.find(3);
// Insertion Sort Example
int[] arr = { 2, 7, 3, 11, 6 };
MySort.InsertionSort(arr);
}
public void Remove_OneElement_ShouldMakeListEmpty()
{
// Arrange
var list = new LinkedList.LinkedList<int>();
list.Add(5);
// Act
var element = list.Remove(0);
// Assert
Assert.AreEqual(5, element);
Assert.AreEqual(0, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>() { });
}
public void Add_SeveralElements_ShouldAddElementsCorrectly()
{
// Arrange
var list = new LinkedList.LinkedList<int>();
// Act
list.Add(10);
list.Add(5);
list.Add(3);
// Assert
Assert.AreEqual(3, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>() { 10, 5 , 3 });
}
public void Remove_SeveralElements_ShouldRemoveElementsCorrectly()
{
// Arrange
var list = new LinkedList.LinkedList<int>();
list.Add(5);
list.Add(6);
list.Add(7);
// Act
var elementOne = list.Remove(0);
var elementTwo = list.Remove(1);
// Assert
Assert.AreEqual(5, elementOne);
Assert.AreEqual(7, elementTwo);
Assert.AreEqual(1, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>() { 6 });
}
public void IEnumerable_NonGeneric_MultipleElements()
{
// Arrange
var list = new LinkedList.LinkedList<decimal>();
list.Add(6m);
list.Add(7.77m);
// Act
var enumerator = ((IEnumerable)list).GetEnumerator();
var items = new List<object>();
while (enumerator.MoveNext())
{
items.Add(enumerator.Current);
}
// Assert
CollectionAssert.AreEqual(items, new List<object>() { 6m, 7.77m });
}
public void IEnumerable_Foreach_MultipleElements()
{
// Arrange
var list = new LinkedList.LinkedList<string>();
list.Add("Five");
list.Add("Six");
list.Add("Seven");
// Act
var items = new List<string>();
foreach (var element in list)
{
items.Add(element);
}
// Assert
CollectionAssert.AreEqual(items,
new List<string>() { "Five", "Six", "Seven" });
}
public void ForEach_MultipleElements_ShouldEnumerateElementsCorrectly()
{
// Arrange
var list = new LinkedList.LinkedList<string>();
list.Add("Five");
list.Add("Six");
list.Add("Seven");
// Act
var items = new List<string>();
list.ForEach(items.Add);
// Assert
CollectionAssert.AreEqual(items,
new List<string>() { "Five", "Six", "Seven" });
}
public void ForEach_SingleElement_ShouldEnumerateElementsCorrectly()
{
// Arrange
var list = new LinkedList.LinkedList<int>();
list.Add(5);
// Act
var items = new List<int>();
list.ForEach(items.Add);
// Assert
CollectionAssert.AreEqual(items, new List<int>() { 5 });
}
public void RemoveLast_SeveralElements_ShouldRemoveElementsCorrectly()
{
// Arrange
var list = new LinkedList.LinkedList<int>();
list.Add(10);
list.Add(9);
list.Add(8);
// Act
var element = list.Remove(2);
// Assert
Assert.AreEqual(8, element);
Assert.AreEqual(2, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>() { 10, 9 });
}
