Esempio n. 1
0
        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);
        }
Esempio n. 2
0
        public void DepthFirstTraversal_Stops_After_Visitor_Completes()
        {
            var visitor = new InOrderVisitor <KeyValuePair <int, string> >(
                new StoppingVisitor <KeyValuePair <int, string> >());

            GetTestTree().DepthFirstTraversal(visitor);
        }
Esempio n. 3
0
            public static void Visitor()
            {
                IElement e  = new ConcreteElement();
                IVisitor io = new InOrderVisitor();
                IVisitor ro = new ReverseOrderVisitor();

                e.Accept(io);
                e.Accept(ro);
            }
Esempio n. 4
0
 /// <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 IEnumerator <T> GetOrderedEnumerator()
        {
            if (tree != null)
            {
                var trackingVisitor = new TrackingVisitor <T>();
                var inOrderVisitor  = new InOrderVisitor <T>(trackingVisitor);

                tree.DepthFirstTraversal(inOrderVisitor);

                var trackingList = trackingVisitor.TrackingList;

                for (var i = 0; i < trackingList.Count; i++)
                {
                    yield return(trackingList[i]);
                }
            }
        }
Esempio n. 6
0
        public void VisitIn()
        {
            var binaryTree      = GetTestTree();
            var trackingVisitor = new TrackingVisitor <int>();
            var inVisitor       = new InOrderVisitor <int>(trackingVisitor);

            binaryTree.DepthFirstTraversal(inVisitor);

            var tracks = trackingVisitor.TrackingList;

            Assert.AreEqual(tracks[0], 9);
            Assert.AreEqual(tracks[1], 2);
            Assert.AreEqual(tracks[2], 12);
            Assert.AreEqual(tracks[3], 5);
            Assert.AreEqual(tracks[4], 13);
            Assert.AreEqual(tracks[5], 3);
        }
Esempio n. 7
0
        public void TestDepthFirstVisitIn()
        {
            BinaryTree <int>      t = GetTestTree();
            TrackingVisitor <int> trackingVisitor = new TrackingVisitor <int>();
            InOrderVisitor <int>  inVisitor       = new InOrderVisitor <int>(trackingVisitor);

            t.DepthFirstTraversal(inVisitor);

            VisitableList <int> tracks = trackingVisitor.TrackingList;

            Assert.AreEqual(tracks[0], 9);
            Assert.AreEqual(tracks[1], 2);
            Assert.AreEqual(tracks[2], 12);
            Assert.AreEqual(tracks[3], 5);
            Assert.AreEqual(tracks[4], 13);
            Assert.AreEqual(tracks[5], 3);
        }
Esempio n. 8
0
        /// <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)
            {
                TrackingVisitor <Association <TKey, TValue> > trackingVisitor = new TrackingVisitor <Association <TKey, TValue> >();
                InOrderVisitor <Association <TKey, TValue> >  inOrderVisitor  = new InOrderVisitor <Association <TKey, TValue> >(trackingVisitor);

                tree.DepthFirstTraversal(inOrderVisitor);

                List <Association <TKey, TValue> > trackingList = trackingVisitor.TrackingList;

                for (int i = 0; i < trackingList.Count; i++)
                {
                    yield return(trackingList[i].ToKeyValuePair());
                }
            }
        }
Esempio n. 9
0
        public void Simple()
        {
            var splayTree = new SplayTree <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 AssertionVisitor <KeyValuePair <string, int> >();

            var inOrderVisitor = new InOrderVisitor <KeyValuePair <string, int> >(visitor);

            splayTree.DepthFirstTraversal(inOrderVisitor);

            visitor.AssertTracked(x => x.Key, "canary", "cat", "dog", "horse");
        }
Esempio n. 10
0
        public void DepthFirstTraversal_Simple()
        {
            var visitor        = new TrackingVisitor <KeyValuePair <string, int> >();
            var inOrderVisitor = new InOrderVisitor <KeyValuePair <string, int> >(visitor);

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

            tree.DepthFirstTraversal(inOrderVisitor);

            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);
        }
Esempio n. 11
0
        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");
        }
Esempio n. 12
0
        public void Simple()
        {
            var splayTree = new SplayTree <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);

            splayTree.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");
        }
Esempio n. 13
0
        public void VisitIn()
        {
            var binaryTree = GetTestTree();
            var trackingVisitor = new TrackingVisitor<int>();
            var inVisitor = new InOrderVisitor<int>(trackingVisitor);

            binaryTree.DepthFirstTraversal(inVisitor);

            var tracks = trackingVisitor.TrackingList;

            Assert.AreEqual(tracks[0], 9);
            Assert.AreEqual(tracks[1], 2);
            Assert.AreEqual(tracks[2], 12);
            Assert.AreEqual(tracks[3], 5);
            Assert.AreEqual(tracks[4], 13);
            Assert.AreEqual(tracks[5], 3);
        }
Esempio n. 14
0
        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);
        }
Esempio n. 15
0
    public void ShouldVisitEachNodeInDescendingOrder() {
      AndersonTree<int, int> tree = new AndersonTree<int, int>();

      Stack<int> data = new Stack<int>(10);
      for (int i = 0; i < 10; i++) {
        data.Push(i*10);
        tree.Add(i*10, i*10);
      }

      var visitor =
        new InOrderVisitor<int, int>(
          new Visitor<int, int>(
            (key, value, state) => Assert.AreEqual(data.Pop(), value)));
      tree.Accept(visitor, true);
    }
Esempio n. 16
0
    public void ShouldVisitEachNodeInAscendingOrder() {
      AndersonTree<int, int> tree = new AndersonTree<int, int>();

      Queue<int> data = new Queue<int>(10);
      for (int i = 0; i < 10; i++) {
        data.Enqueue(i*10);
        tree.Add(i*10, i*10);
      }

      var visitor =
        new InOrderVisitor<int, int>(
          new Visitor<int, int>(
            (key, value, state) => Assert.AreEqual(data.Dequeue(), value)));
      tree.Accept(visitor, false);
    }