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); }