public void TopologicalSortTraversalExample()
{
// Create a new directed graph
var graph = new Graph <int>(true);
var vertex1 = graph.AddVertex(1);
var vertex2 = graph.AddVertex(2);
var vertex3 = graph.AddVertex(3);
var vertex4 = graph.AddVertex(4);
// Add some edges
graph.AddEdge(vertex1, vertex2);
graph.AddEdge(vertex2, vertex3);
graph.AddEdge(vertex2, vertex4);
graph.AddEdge(vertex3, vertex4);
// Create a new tracking visitor to keep track of the vertices visited.
var trackingVisitor = new TrackingVisitor <Vertex <int> >();
// Visit each vertex in the graph in topological order.
graph.TopologicalSortTraversal(trackingVisitor);
// Retrieve the tracking list from the visitor
var vertices = trackingVisitor.TrackingList;
// There will be 4 items in the list
Assert.AreEqual(4, vertices.Count);
// And the topological order of the sample graph is vertex1, vertex2, vertex3, and vertex4.
Assert.AreSame(vertex1, vertices[0]);
Assert.AreSame(vertex2, vertices[1]);
Assert.AreSame(vertex3, vertices[2]);
Assert.AreSame(vertex4, vertices[3]);
}
public void Simple()
{
var graph = new Graph <int>(false);
var vertices = new Vertex <int> [20];
for (var i = 0; i < 20; i++)
{
vertices[i] = new Vertex <int>(i);
graph.AddVertex(vertices[i]);
}
for (var i = 0; i < 17; i += 2)
{
var edge = new Edge <int>(vertices[i], vertices[i + 2], false);
graph.AddEdge(edge);
}
var trackingVisitor = new TrackingVisitor <int>();
graph.AcceptVisitor(trackingVisitor);
Assert.AreEqual(trackingVisitor.TrackingList.Count, 20);
for (var i = 0; i < 20; i++)
{
Assert.IsTrue(trackingVisitor.TrackingList.Contains(i));
}
}
public void Simple()
{
var graph = new Graph<int>(false);
var vertices = new Vertex<int>[20];
for (var i = 0; i < 20; i++)
{
vertices[i] = new Vertex<int>(i);
graph.AddVertex(vertices[i]);
}
for (var i = 0; i < 17; i += 2)
{
var edge = new Edge<int>(vertices[i], vertices[i + 2], false);
graph.AddEdge(edge);
}
var trackingVisitor = new TrackingVisitor<int>();
graph.AcceptVisitor(trackingVisitor);
Assert.AreEqual(trackingVisitor.TrackingList.Count, 20);
for (var i = 0; i < 20; i++)
{
Assert.IsTrue(trackingVisitor.TrackingList.Contains(i));
}
}
public void DepthFirstTraversalExample()
{
// Create a simple tree
var tree = new RedBlackTree <string, int>
{
new KeyValuePair <string, int>("horse", 4),
new KeyValuePair <string, int>("cat", 1),
new KeyValuePair <string, int>("dog", 2),
new KeyValuePair <string, int>("canary", 3)
};
// Create a tracking visitor which will track the items
// the tree calls visit on.
var visitor = new TrackingVisitor <KeyValuePair <string, int> >();
// We'll wrap the tracking visitor in an ordered visitor and visit
// the items in in-order order. Effectively the visitor would visit
// the items in sorted order.
var inOrderVisitor =
new InOrderVisitor <KeyValuePair <string, int> >(visitor);
// Perform a depth-first traversal of the tree.
tree.DepthFirstTraversal(inOrderVisitor);
// The tracking list has the items in sorted order.
Assert.AreEqual("canary", visitor.TrackingList[0].Key);
Assert.AreEqual("cat", visitor.TrackingList[1].Key);
Assert.AreEqual("dog", visitor.TrackingList[2].Key);
Assert.AreEqual("horse", visitor.TrackingList[3].Key);
}
public IList <Vertex <T> > TopologicalSort()
{
var visitor = new TrackingVisitor <Vertex <T> >();
TopologicalSortTraversal(visitor);
return(visitor.TrackingList);
}
public void Simple()
{
var visitor = new TrackingVisitor <int>();
var orderedVisitor = new OrderedVisitor <int>(visitor);
Assert.IsFalse(orderedVisitor.HasCompleted);
Assert.AreSame(orderedVisitor.VisitorToUse, visitor);
}
public void Simple()
{
var visitor = new TrackingVisitor<int>();
var orderedVisitor = new OrderedVisitor<int>(visitor);
Assert.IsFalse(orderedVisitor.HasCompleted);
Assert.AreSame(orderedVisitor.VisitorToUse, visitor);
}
public void Empty()
{
var circularQueue = new CircularQueue <int>(40);
var visitor = new TrackingVisitor <int>();
circularQueue.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 0);
}
public void Empty()
{
var circularQueue = new CircularQueue<int>(40);
var visitor = new TrackingVisitor<int>();
circularQueue.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 0);
}
public void Simple()
{
var a = false;
var b = false;
var c = false;
var d = false;
var e = false;
var f = false;
var count = 0;
var priorityQueue = GetSimpleTestPriorityQueue();
var visitor = new TrackingVisitor <string>();
priorityQueue.AcceptVisitor(visitor);
foreach (var t in visitor.TrackingList)
{
count++;
if (t == "a")
{
a = true;
}
else if (t == "b")
{
b = true;
}
else if (t == "c")
{
c = true;
}
else if (t == "d")
{
d = true;
}
else if (t == "e")
{
e = true;
}
else if (t == "f")
{
f = true;
}
}
Assert.IsTrue(a);
Assert.IsTrue(b);
Assert.IsTrue(c);
Assert.IsTrue(d);
Assert.IsTrue(e);
Assert.IsTrue(f);
Assert.AreEqual(count, 6);
}
public void Simple()
{
var a = false;
var b = false;
var c = false;
var d = false;
var e = false;
var f = false;
var count = 0;
var priorityQueue = GetSimpleTestPriorityQueue();
var visitor = new TrackingVisitor<string>();
priorityQueue.AcceptVisitor(visitor);
foreach (var t in visitor.TrackingList)
{
count++;
if (t == "a")
{
a = true;
}
else if (t == "b")
{
b = true;
}
else if (t == "c")
{
c = true;
}
else if (t == "d")
{
d = true;
}
else if (t == "e")
{
e = true;
}
else if (t == "f")
{
f = true;
}
}
Assert.IsTrue(a);
Assert.IsTrue(b);
Assert.IsTrue(c);
Assert.IsTrue(d);
Assert.IsTrue(e);
Assert.IsTrue(f);
Assert.AreEqual(count, 6);
}
public void TestAccept()
{
bool a = false;
bool b = false;
bool c = false;
bool d = false;
bool e = false;
bool f = false;
int count = 0;
PriorityQueue <string> q = GetSimpleTestPriorityQueue();
TrackingVisitor <string> visitor = new TrackingVisitor <string>();
q.Accept(visitor);
for (int i = 0; i < visitor.TrackingList.Count; i++)
{
count++;
if (visitor.TrackingList[i] == "a")
{
a = true;
}
else if (visitor.TrackingList[i] == "b")
{
b = true;
}
else if (visitor.TrackingList[i] == "c")
{
c = true;
}
else if (visitor.TrackingList[i] == "d")
{
d = true;
}
else if (visitor.TrackingList[i] == "e")
{
e = true;
}
else if (visitor.TrackingList[i] == "f")
{
f = true;
}
}
Assert.AreEqual(a, true);
Assert.AreEqual(b, true);
Assert.AreEqual(c, true);
Assert.AreEqual(d, true);
Assert.AreEqual(e, true);
Assert.AreEqual(f, true);
Assert.AreEqual(count, 6);
}
public void Simple2()
{
var bag = new Bag<string> { "5", "4", "3", "2" };
var visitor = new TrackingVisitor<KeyValuePair<string, int>>();
bag.AcceptVisitor<KeyValuePair<string, int>>(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 4);
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<string, int>("5", 1)));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<string, int>("4", 1)));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<string, int>("3", 1)));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<string, int>("2", 1)));
}
public void Simple()
{
var bag = new Bag<string> { "5", "4", "3", "2" };
var visitor = new TrackingVisitor<string>();
bag.AcceptVisitor<string>(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 4);
Assert.IsTrue(visitor.TrackingList.Contains("5"));
Assert.IsTrue(visitor.TrackingList.Contains("4"));
Assert.IsTrue(visitor.TrackingList.Contains("3"));
Assert.IsTrue(visitor.TrackingList.Contains("2"));
}
public void Simple()
{
var visitor = new TrackingVisitor<int>();
var sortedList = SortedListTest.GetTestList();
sortedList.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, sortedList.Count);
for (var i = 0; i <= 50; i++)
{
Assert.IsTrue(visitor.TrackingList.Contains(i * 2));
}
}
public void Simple()
{
var visitor = new TrackingVisitor <int>();
var sortedList = SortedListTest.GetTestList();
sortedList.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, sortedList.Count);
for (var i = 0; i <= 50; i++)
{
Assert.IsTrue(visitor.TrackingList.Contains(i * 2));
}
}
public void Simple()
{
var visitor = new TrackingVisitor<int>();
var heap = GetTestHeap();
heap.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, heap.Count);
Assert.IsTrue(visitor.TrackingList.Contains(5));
Assert.IsTrue(visitor.TrackingList.Contains(4));
Assert.IsTrue(visitor.TrackingList.Contains(99));
Assert.IsTrue(visitor.TrackingList.Contains(12));
Assert.IsTrue(visitor.TrackingList.Contains(5));
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns> A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection. </returns>
public IEnumerator <KeyValuePair <TKey, TValue> > GetSortedEnumerator()
{
if (_tree != null)
{
var trackingVisitor = new TrackingVisitor <Association <TKey, TValue> >();
var inOrderVisitor = new InOrderVisitor <Association <TKey, TValue> >(trackingVisitor);
_tree.DepthFirstTraversal(inOrderVisitor);
var trackingList = trackingVisitor.TrackingList;
foreach (var assoc in trackingList)
{
yield return(assoc.ToKeyValuePair());
}
}
}
public void Simple()
{
var visitor = new TrackingVisitor <int>();
var heap = GetTestHeap();
heap.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, heap.Count);
Assert.IsTrue(visitor.TrackingList.Contains(5));
Assert.IsTrue(visitor.TrackingList.Contains(4));
Assert.IsTrue(visitor.TrackingList.Contains(99));
Assert.IsTrue(visitor.TrackingList.Contains(12));
Assert.IsTrue(visitor.TrackingList.Contains(5));
}
public void TestAccept()
{
TrackingVisitor <int> visitor = new TrackingVisitor <int>();
Heap <int> h = GetTestHeap();
h.Accept(visitor);
Assert.AreEqual(visitor.TrackingList.Count, h.Count);
Assert.AreEqual(visitor.TrackingList.Contains(5), true);
Assert.AreEqual(visitor.TrackingList.Contains(4), true);
Assert.AreEqual(visitor.TrackingList.Contains(99), true);
Assert.AreEqual(visitor.TrackingList.Contains(12), true);
Assert.AreEqual(visitor.TrackingList.Contains(5), true);
}
public void TestAccept()
{
TrackingVisitor <int> visitor = new TrackingVisitor <int>();
SortedList <int> s = GetTestList();
s.Accept(visitor);
Assert.AreEqual(visitor.TrackingList.Count, s.Count);
for (int i = 0; i <= 50; i++)
{
Assert.AreEqual(visitor.TrackingList.Contains(i * 2), true);
}
}
public void Simple()
{
var redBlackTree = GetTestTree();
var visitor = new TrackingVisitor<KeyValuePair<int, string>>();
redBlackTree.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 100);
for (var i = 0; i < 100; i++)
{
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<int, string>(i, i.ToString())));
}
}
public void Simple()
{
var binaryTree = GetTestTree();
var trackingVisitor = new TrackingVisitor<int>();
binaryTree.AcceptVisitor(trackingVisitor);
Assert.AreEqual(trackingVisitor.TrackingList.Count, 6);
Assert.IsTrue(trackingVisitor.TrackingList.Contains(5));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(2));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(3));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(9));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(12));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(13));
}
public void TestAccept()
{
PascalSet s = new PascalSet(0, 50, new int[] { 15, 20, 30, 40, 34 });
TrackingVisitor <int> v = new TrackingVisitor <int>();
s.Accept(v);
Assert.AreEqual(v.TrackingList.Count, 5);
Assert.AreEqual(v.TrackingList.Contains(15), true);
Assert.AreEqual(v.TrackingList.Contains(20), true);
Assert.AreEqual(v.TrackingList.Contains(30), true);
Assert.AreEqual(v.TrackingList.Contains(40), true);
Assert.AreEqual(v.TrackingList.Contains(34), true);
}
public void Simple()
{
var pascalSet = new PascalSet(0, 50, new[] { 15, 20, 30, 40, 34 });
var trackingVisitor = new TrackingVisitor<int>();
pascalSet.AcceptVisitor(trackingVisitor);
Assert.AreEqual(trackingVisitor.TrackingList.Count, 5);
Assert.IsTrue(trackingVisitor.TrackingList.Contains(15));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(20));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(30));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(40));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(34));
}
public void Simple()
{
var redBlackTree = GetTestTree();
var visitor = new TrackingVisitor <KeyValuePair <int, string> >();
redBlackTree.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 100);
for (var i = 0; i < 100; i++)
{
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <int, string>(i, i.ToString())));
}
}
public void Simple()
{
var pascalSet = new PascalSet(0, 50, new[] { 15, 20, 30, 40, 34 });
var trackingVisitor = new TrackingVisitor <int>();
pascalSet.AcceptVisitor(trackingVisitor);
Assert.AreEqual(trackingVisitor.TrackingList.Count, 5);
Assert.IsTrue(trackingVisitor.TrackingList.Contains(15));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(20));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(30));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(40));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(34));
}
public void TestAccept()
{
RedBlackTree <int, string> tree = GetTestTree();
TrackingVisitor <KeyValuePair <int, string> > visitor = new TrackingVisitor <KeyValuePair <int, string> >();
tree.Accept(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 100);
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(visitor.TrackingList.Contains(new KeyValuePair <int, string>(i, i.ToString())), true);
}
}
public void HalfFull()
{
var circularQueue = CircularQueueTest.GetHalfFullTestQueue();
var visitor = new TrackingVisitor<int>();
circularQueue.AcceptVisitor(visitor);
var list = new List<int>(visitor.TrackingList);
Assert.AreEqual(list.Count, 200);
for (var i = 0; i < 200; i++)
{
Assert.IsTrue(list.Contains(i));
}
}
public void Simple()
{
var tree = GetTestTree();
var visitor = new TrackingVisitor <KeyValuePair <int, string> >();
tree.AcceptVisitor(visitor);
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <int, string>(4, "4")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <int, string>(6, "6")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <int, string>(2, "2")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <int, string>(5, "5")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <int, string>(19, "19")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <int, string>(1, "1")));
Assert.AreEqual(visitor.TrackingList.Count, 6);
}
public void Simple()
{
var deque = new Deque<int>();
deque.EnqueueHead(5);
deque.EnqueueHead(3);
deque.EnqueueHead(2);
var visitor = new TrackingVisitor<int>();
deque.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 3);
Assert.IsTrue(visitor.TrackingList.Contains(5));
Assert.IsTrue(visitor.TrackingList.Contains(3));
Assert.IsTrue(visitor.TrackingList.Contains(2));
}
public void TestBreadthFirstVisit()
{
BinaryTree <int> t = GetTestTree();
TrackingVisitor <int> trackingVisitor = new TrackingVisitor <int>();
t.BreadthFirstTraversal(trackingVisitor);
VisitableList <int> tracks = trackingVisitor.TrackingList;
Assert.AreEqual(tracks[0], 5);
Assert.AreEqual(tracks[1], 2);
Assert.AreEqual(tracks[2], 3);
Assert.AreEqual(tracks[3], 9);
Assert.AreEqual(tracks[4], 12);
Assert.AreEqual(tracks[5], 13);
}
public void Simple()
{
var bag = new Bag <string> {
"5", "4", "3", "2"
};
var visitor = new TrackingVisitor <string>();
bag.AcceptVisitor <string>(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 4);
Assert.IsTrue(visitor.TrackingList.Contains("5"));
Assert.IsTrue(visitor.TrackingList.Contains("4"));
Assert.IsTrue(visitor.TrackingList.Contains("3"));
Assert.IsTrue(visitor.TrackingList.Contains("2"));
}
public void TestAccept()
{
BinaryTree <int> t = GetTestTree();
TrackingVisitor <int> v = new TrackingVisitor <int>();
t.Accept(v);
Assert.AreEqual(v.TrackingList.Count, 6);
Assert.AreEqual(v.TrackingList.Contains(5), true);
Assert.AreEqual(v.TrackingList.Contains(2), true);
Assert.AreEqual(v.TrackingList.Contains(3), true);
Assert.AreEqual(v.TrackingList.Contains(9), true);
Assert.AreEqual(v.TrackingList.Contains(12), true);
Assert.AreEqual(v.TrackingList.Contains(13), true);
}
public void TestAccept()
{
List <SimpleClass> simpleList = GetTestSimpleClassList();
ReadOnlyPropertyList <SimpleClass, string> list = new ReadOnlyPropertyList <SimpleClass, string>(simpleList, property);
TrackingVisitor <string> v = new TrackingVisitor <string>();
list.Accept(v);
Assert.AreEqual(v.TrackingList.Count, 20);
for (int i = 0; i < 20; i++)
{
Assert.AreEqual(v.TrackingList.Contains(i.ToString()), true);
}
}
public void TestAccept()
{
BinarySearchTree <int, string> tree = GetTestTree();
TrackingVisitor <KeyValuePair <int, string> > visitor = new TrackingVisitor <KeyValuePair <int, string> >();
tree.Accept(visitor);
Assert.AreEqual(visitor.TrackingList.Contains(new KeyValuePair <int, string>(4, "4")), true);
Assert.AreEqual(visitor.TrackingList.Contains(new KeyValuePair <int, string>(6, "6")), true);
Assert.AreEqual(visitor.TrackingList.Contains(new KeyValuePair <int, string>(2, "2")), true);
Assert.AreEqual(visitor.TrackingList.Contains(new KeyValuePair <int, string>(5, "5")), true);
Assert.AreEqual(visitor.TrackingList.Contains(new KeyValuePair <int, string>(19, "19")), true);
Assert.AreEqual(visitor.TrackingList.Contains(new KeyValuePair <int, string>(1, "1")), true);
Assert.AreEqual(visitor.TrackingList.Count, 6);
}
public void Simple()
{
var tree = GetTestTree();
var visitor = new TrackingVisitor<KeyValuePair<int, string>>();
tree.AcceptVisitor(visitor);
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<int, string>(4, "4")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<int, string>(6, "6")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<int, string>(2, "2")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<int, string>(5, "5")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<int, string>(19, "19")));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair<int, string>(1, "1")));
Assert.AreEqual(visitor.TrackingList.Count, 6);
}
public void Simple()
{
var binaryTree = GetTestTree();
var trackingVisitor = new TrackingVisitor <int>();
binaryTree.AcceptVisitor(trackingVisitor);
Assert.AreEqual(trackingVisitor.TrackingList.Count, 6);
Assert.IsTrue(trackingVisitor.TrackingList.Contains(5));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(2));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(3));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(9));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(12));
Assert.IsTrue(trackingVisitor.TrackingList.Contains(13));
}
public void HalfFull()
{
var circularQueue = CircularQueueTest.GetHalfFullTestQueue();
var visitor = new TrackingVisitor <int>();
circularQueue.AcceptVisitor(visitor);
var list = new List <int>(visitor.TrackingList);
Assert.AreEqual(list.Count, 200);
for (var i = 0; i < 200; i++)
{
Assert.IsTrue(list.Contains(i));
}
}
public void Simple2()
{
var bag = new Bag <string> {
"5", "4", "3", "2"
};
var visitor = new TrackingVisitor <KeyValuePair <string, int> >();
bag.AcceptVisitor <KeyValuePair <string, int> >(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 4);
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <string, int>("5", 1)));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <string, int>("4", 1)));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <string, int>("3", 1)));
Assert.IsTrue(visitor.TrackingList.Contains(new KeyValuePair <string, int>("2", 1)));
}
public void Overrun()
{
var circularQueue = CircularQueueTest.GetOverrunTestQueue();
var visitor = new TrackingVisitor <int>();
circularQueue.AcceptVisitor(visitor);
var list = new List <int>(visitor.TrackingList);
Assert.AreEqual(list.Count, 40);
for (var i = 60; i < 100; i++)
{
Assert.IsTrue(list.Contains(i));
}
}
public void Simple()
{
var binaryTree = GetTestTree();
var trackingVisitor = new TrackingVisitor <int>();
binaryTree.BreadthFirstTraversal(trackingVisitor);
var tracks = trackingVisitor.TrackingList;
Assert.AreEqual(tracks[0], 5);
Assert.AreEqual(tracks[1], 2);
Assert.AreEqual(tracks[2], 3);
Assert.AreEqual(tracks[3], 9);
Assert.AreEqual(tracks[4], 12);
Assert.AreEqual(tracks[5], 13);
}
public void Simple()
{
var binaryTree = GetTestTree();
var trackingVisitor = new TrackingVisitor<int>();
binaryTree.BreadthFirstTraversal(trackingVisitor);
var tracks = trackingVisitor.TrackingList;
Assert.AreEqual(tracks[0], 5);
Assert.AreEqual(tracks[1], 2);
Assert.AreEqual(tracks[2], 3);
Assert.AreEqual(tracks[3], 9);
Assert.AreEqual(tracks[4], 12);
Assert.AreEqual(tracks[5], 13);
}
public void TestVisitor()
{
TrackingVisitor <KeyValuePair <string, string> > visitor = new TrackingVisitor <KeyValuePair <string, string> >();
VisitableHashtable <string, string> h = GetTestHashtable();
h.Accept(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 3);
bool found = false;
for (int i = 0; i < visitor.TrackingList.Count; i++)
{
if ((visitor.TrackingList[i].Key == "a") && (visitor.TrackingList[i].Value == "aa"))
{
found = true;
break;
}
}
Assert.AreEqual(found, true);
found = false;
for (int i = 0; i < visitor.TrackingList.Count; i++)
{
if ((visitor.TrackingList[i].Key == "b") && (visitor.TrackingList[i].Value == "bb"))
{
found = true;
break;
}
}
Assert.AreEqual(found, true);
found = false;
for (int i = 0; i < visitor.TrackingList.Count; i++)
{
if ((visitor.TrackingList[i].Key == "c") && (visitor.TrackingList[i].Value == "cc"))
{
found = true;
break;
}
}
Assert.AreEqual(found, true);
}
public void Pre()
{
var binaryTree = GetTestTree();
var trackingVisitor = new TrackingVisitor<int>();
var preVisitor = new PreOrderVisitor<int>(trackingVisitor);
binaryTree.DepthFirstTraversal(preVisitor);
var tracks = trackingVisitor.TrackingList;
Assert.AreEqual(tracks[0], 5);
Assert.AreEqual(tracks[1], 2);
Assert.AreEqual(tracks[2], 9);
Assert.AreEqual(tracks[3], 12);
Assert.AreEqual(tracks[4], 3);
Assert.AreEqual(tracks[5], 13);
}
public void Simple()
{
var visitor = new TrackingVisitor<double>();
var matrix = MatrixTest.GetTestMatrix();
matrix.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, matrix.Rows * matrix.Columns);
for (var i = 0; i < matrix.Rows; i++)
{
for (var j = 0; j < matrix.Columns; j++)
{
Assert.IsTrue(visitor.TrackingList.Contains(i + j));
}
}
}
public void Simple()
{
var visitor = new TrackingVisitor <double>();
var matrix = MatrixTest.GetTestMatrix();
matrix.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, matrix.Rows * matrix.Columns);
for (var i = 0; i < matrix.Rows; i++)
{
for (var j = 0; j < matrix.Columns; j++)
{
Assert.IsTrue(visitor.TrackingList.Contains(i + j));
}
}
}
public void ExceptionTraversalException()
{
var graph = new Graph<int>(true);
var vertex1 = graph.AddVertex(1);
var vertex2 = graph.AddVertex(2);
var vertex3 = graph.AddVertex(3);
var vertex4 = graph.AddVertex(4);
graph.AddEdge(vertex1, vertex2);
graph.AddEdge(vertex2, vertex3);
graph.AddEdge(vertex2, vertex4);
graph.AddEdge(vertex3, vertex4);
graph.AddEdge(vertex4, vertex1);
var visitor = new TrackingVisitor<Vertex<int>>();
graph.TopologicalSortTraversal(visitor);
}
public void Directed()
{
var graph = new Graph<int>(true);
var vertex1 = new Vertex<int>(1);
var vertex2 = new Vertex<int>(2);
var vertex3 = new Vertex<int>(3);
var vertex4 = new Vertex<int>(4);
var vertex5 = new Vertex<int>(5);
var vertex6 = new Vertex<int>(6);
var vertex7 = new Vertex<int>(7);
graph.AddVertex(vertex1);
graph.AddVertex(vertex2);
graph.AddVertex(vertex3);
graph.AddVertex(vertex4);
graph.AddVertex(vertex5);
graph.AddVertex(vertex6);
graph.AddVertex(vertex7);
graph.AddEdge(vertex1, vertex2);
graph.AddEdge(vertex1, vertex3);
graph.AddEdge(vertex1, vertex5);
graph.AddEdge(vertex5, vertex3);
graph.AddEdge(vertex3, vertex6);
graph.AddEdge(vertex3, vertex4);
graph.AddEdge(vertex2, vertex7);
var trackingVisitor = new TrackingVisitor<Vertex<int>>();
graph.BreadthFirstTraversal(trackingVisitor, vertex1);
Assert.AreEqual(trackingVisitor.TrackingList.Count, graph.Vertices.Count);
Assert.AreEqual(trackingVisitor.TrackingList[0].Data, 1);
Assert.AreEqual(trackingVisitor.TrackingList[1].Data, 2);
Assert.AreEqual(trackingVisitor.TrackingList[2].Data, 3);
Assert.AreEqual(trackingVisitor.TrackingList[3].Data, 5);
Assert.AreEqual(trackingVisitor.TrackingList[4].Data, 7);
Assert.AreEqual(trackingVisitor.TrackingList[5].Data, 6);
Assert.AreEqual(trackingVisitor.TrackingList[6].Data, 4);
}
public void Simple()
{
var tree = new BinarySearchTree<string, int>
{
new KeyValuePair<string, int>("horse", 4),
new KeyValuePair<string, int>("cat", 1),
new KeyValuePair<string, int>("dog", 2),
new KeyValuePair<string, int>("canary", 3)
};
var visitor = new TrackingVisitor<KeyValuePair<string, int>>();
var inOrderVisitor =
new InOrderVisitor<KeyValuePair<string, int>>(visitor);
tree.DepthFirstTraversal(inOrderVisitor);
Assert.AreEqual(visitor.TrackingList[0].Key, "canary");
Assert.AreEqual(visitor.TrackingList[1].Key, "cat");
Assert.AreEqual(visitor.TrackingList[2].Key, "dog");
Assert.AreEqual(visitor.TrackingList[3].Key, "horse");
}
public void Simple()
{
var skipList = new SkipList<int, string>();
for (var i = 0; i < 100; i++)
{
skipList.Add(i, i.ToString());
}
var visitor = new TrackingVisitor<KeyValuePair<int, string>>();
skipList.AcceptVisitor(visitor);
Assert.AreEqual(visitor.TrackingList.Count, 100);
using (var enumerator = skipList.GetEnumerator())
{
while (enumerator.MoveNext())
{
Assert.IsTrue(visitor.TrackingList.Contains(enumerator.Current));
}
}
}
public void DepthFirstTraversalExample()
{
// Create a simple tree
var tree = new RedBlackTree<string, int>
{
new KeyValuePair<string, int>("horse", 4),
new KeyValuePair<string, int>("cat", 1),
new KeyValuePair<string, int>("dog", 2),
new KeyValuePair<string, int>("canary", 3)
};
// Create a tracking visitor which will track the items
// the tree calls visit on.
var visitor = new TrackingVisitor<KeyValuePair<string, int>>();
// We'll wrap the tracking visitor in an ordered visitor and visit
// the items in in-order order. Effectively the visitor would visit
// the items in sorted order.
var inOrderVisitor =
new InOrderVisitor<KeyValuePair<string,int>>(visitor);
// Perform a depth-first traversal of the tree.
tree.DepthFirstTraversal(inOrderVisitor);
// The tracking list has the items in sorted order.
Assert.AreEqual("canary", visitor.TrackingList[0].Key);
Assert.AreEqual("cat", visitor.TrackingList[1].Key);
Assert.AreEqual("dog", visitor.TrackingList[2].Key);
Assert.AreEqual("horse", visitor.TrackingList[3].Key);
}
public void Overrun()
{
var circularQueue = CircularQueueTest.GetOverrunTestQueue();
var visitor = new TrackingVisitor<int>();
circularQueue.AcceptVisitor(visitor);
var list = new List<int>(visitor.TrackingList);
Assert.AreEqual(list.Count, 40);
for (var i = 60; i < 100; i++)
{
Assert.IsTrue(list.Contains(i));
}
}
public void TopologicalSortTraversalExample()
{
// Create a new directed graph
var graph = new Graph<int>(true);
var vertex1 = graph.AddVertex(1);
var vertex2 = graph.AddVertex(2);
var vertex3 = graph.AddVertex(3);
var vertex4 = graph.AddVertex(4);
// Add some edges
graph.AddEdge(vertex1, vertex2);
graph.AddEdge(vertex2, vertex3);
graph.AddEdge(vertex2, vertex4);
graph.AddEdge(vertex3, vertex4);
// Create a new tracking visitor to keep track of the vertices visited.
var trackingVisitor = new TrackingVisitor<Vertex<int>>();
// Visit each vertex in the graph in topological order.
graph.TopologicalSortTraversal(trackingVisitor);
// Retrieve the tracking list from the visitor
var vertices = trackingVisitor.TrackingList;
// There will be 4 items in the list
Assert.AreEqual(vertices.Count, 4);
// And the topological order of the sample graph is vertex1, vertex2, vertex3, and vertex4.
Assert.AreSame(vertices[0], vertex1);
Assert.AreSame(vertices[1], vertex2);
Assert.AreSame(vertices[2], vertex3);
Assert.AreSame(vertices[3], vertex4);
}
