public void StoreSecondValueInLeftNode()
        {
            int            expectedValue = 2;
            DemoTree <int> myTree        = CreateTreeWithValues(expectedValue);

            Assert.AreEqual(expectedValue, myTree.LeftChild.Value);
        }
        public void StoreValueInRootNode()
        {
            int            expectedValue = 1;
            DemoTree <int> myTree        = CreateTreeWithValues(expectedValue);

            Assert.AreEqual(expectedValue, myTree.Value);
        }
        public void StoreThirdValueInRightNode()
        {
            int            expectedValue = 3;
            DemoTree <int> myTree        = CreateTreeWithValues(expectedValue);

            Assert.AreEqual(expectedValue, myTree.RightChild.Value);
        }
        public void StoreFifthValueInLeftRightNode()
        {
            int            expectedValue = 5;
            DemoTree <int> myTree        = CreateTreeWithValues(expectedValue);

            Assert.AreEqual(expectedValue, myTree.LeftChild.RightChild.Value);
        }
Пример #5
0
 public bool MoveNext()
 {
     if (_current == null)
     {
         Reset();
         _current = _tree;
         _enumerators.Enqueue(_current.Children().GetEnumerator());
         return(true);
     }
     while (_enumerators.Count > 0)
     {
         var enumerator = _enumerators.Peek();
         if (enumerator.MoveNext())
         {
             _current = enumerator.Current;
             _enumerators.Enqueue(_current.Children().GetEnumerator());
             return(true);
         }
         else
         {
             _enumerators.Dequeue();
         }
     }
     return(false);
 }
        public void StoreSixthValueInLeftRightNode()
        {
            int            expectedValue = 6;
            DemoTree <int> myTree        = CreateTreeWithValues(expectedValue);

            DisplayTree(myTree);
            Assert.AreEqual(expectedValue, myTree.RightChild.LeftChild.Value);
        }
        public void InitialTreeHasDepthZero()
        {
            var myTree = new DemoTree <int>();

            myTree.Add(1);

            Assert.AreEqual(0, myTree.Depth());
        }
        public void ListValuesInDepthFirstOrderWithEnumerator()
        {
            int            expectedValue = 6;
            DemoTree <int> myTree        = CreateTreeWithValues(expectedValue);

            DisplayTree(myTree);
            var valuesString = string.Join(" ", myTree.ToArray());

            Assert.AreEqual("1 2 4 5 3 6", valuesString);
        }
        private DemoTree <int> CreateTreeWithValues(int numberOfValues)
        {
            if (numberOfValues <= 0)
            {
                return(null);
            }

            var tree = new DemoTree <int>(1);

            for (int i = 2; i <= numberOfValues; i++)
            {
                tree.Add(i);
            }
            return(tree);
        }
 public bool MoveNext()
 {
     if (_current == null)
     {
         Reset();
         _current = _tree;
         return(true);
     }
     if (_current.LeftChild != null)
     {
         return(TraverseLeft());
     }
     if (_current.RightChild != null)
     {
         return(TraverseRight());
     }
     return(TraverseUpAndRight());
 }
Пример #11
0
 public void Add(T value)
 {
     if (LeftChild == null)
     {
         LeftChild = new DemoTree <T>(value);
         return;
     }
     if (RightChild == null)
     {
         RightChild = new DemoTree <T>(value);
         return;
     }
     if (LeftChild.Depth() <= RightChild.Depth())
     {
         LeftChild.Add(value);
         return;
     }
     RightChild.Add(value);
 }
 private bool TraverseUpAndRight()
 {
     if (_breadcrumb.Count > 0)
     {
         _previous = _current;
         while (true)
         {
             _current = _breadcrumb.Pop();
             if (_previous != _current.RightChild)
             {
                 break;
             }
         }
         if (_current.RightChild != null)
         {
             _breadcrumb.Push(_current);
             _current = _current.RightChild;
             return(true);
         }
     }
     return(false);
 }
Пример #13
0
 public DemoTreeBreadthFirstEnumerator(DemoTree <T> tree)
 {
     _tree = tree;
 }
Пример #14
0
 public void Reset()
 {
     _current = null;
     _enumerators.Clear();
 }
 public DemoTreeEnumerator(DemoTree <T> tree)
 {
     _tree = tree;
 }
        public void DisplayTree(DemoTree <int> tree)
        {
            var serializer = new XmlSerializer(tree.GetType());

            serializer.Serialize(Console.Out, tree);
        }
        public void StartEmpty()
        {
            var myTree = new DemoTree <string>();

            Assert.IsNull(myTree.Value);
        }
 private bool TraverseRight()
 {
     _breadcrumb.Push(_current);
     _current = _current.RightChild;
     return(true);
 }
 public void Reset()
 {
     _current = null;
 }