二叉树及其实例 二 ( Binary Tree b.)

1.广度便历二叉树，得到二叉树的深度

     使用队列

2.深度便历二叉树,   得到二叉树的深度

    使用堆栈

Test ：

/// <summary>
       ///A test for GetDepth
       ///</summary>
       [TestMethod()]
       public void GetDepthByDepthTraverse()
       {
           BinTree<int> target = new BinTree<int>(); // TODO: Initialize to an appropriate value

           Random rand = new Random();

           for (int i = 0; i < 13; i++)
           {
               int level = i;

               int possibility = 100;
               bool isFullTree = (possibility == 100);
               BinTree<int> actual = target.BuildRandom(level, 100);
               Int32 nodeCount;
               int depth = actual.GetDepthByDepthTraverse(out nodeCount);
               if (depth != level)
               {

               }
               if (isFullTree)
               {
                   Assert.AreEqual(Math.Pow(2, depth) - 1, nodeCount);
               }
               Assert.AreEqual(depth, level);
           }

       }

 

       /// <summary>
       ///A test for GetDepthByWideTraverse
       ///</summary>
       [TestMethod()]
       public void GetDepthByWideTraverse()
       {
           BinTree<int> target = new BinTree<int>(); // TODO: Initialize to an appropriate value

           Random rand = new Random();

           for (int i = 0; i < 11; i++)
           {
               int level = i;

               int possibility = 100;
               bool isFullTree = (possibility == 100);
               BinTree<int> actual = target.BuildRandom(level, 100);
               Int32 nodeCount;
               int depth = actual.GetDepthByWideTraverse(out nodeCount);
               if (depth != level)
               {

               }
               if (isFullTree)
               {
                   Assert.AreEqual(Math.Pow(2, depth) - 1, nodeCount);
               }
               Assert.AreEqual(depth, level);
           }
       }

 

实现：

public Int32 GetDepthByWideTraverse(out int nodeCount)
       {
           if (Root == null)
           {
               nodeCount = 0;
               return 0;
           }

           Int32 depth = 0;
           Int32 preQueCount = 0;
           bool hasDecendant = false;
           Int32 nodeCounter = 0;
           Queue<BinTreeNode<T>> que = new Queue<BinTreeNode<T>>();
           que.Enqueue(Root);
           nodeCounter++;
           preQueCount = que.Count;

           do
           {
               depth++;
               hasDecendant = false;
               for (int i = 0; i < preQueCount; i++)
               {
                   BinTreeNode<T> node = que.Dequeue();

                   if (node.LeftChild != null)
                   {
                       hasDecendant = true;
                       que.Enqueue(node.LeftChild);
                       nodeCounter++;
                   }

                   if (node.RightChild != null)
                   {
                       hasDecendant = true;
                       que.Enqueue(node.RightChild);
                       nodeCounter++;
                   }
               }

               preQueCount = que.Count;
           }
           while (hasDecendant);

           nodeCount = nodeCounter;

           return depth;
       }

       public Int32 GetDepthByDepthTraverse(out int nodeCount)
       {
           BinTreeNode<T> tempNode = Root;
           if (tempNode == null)
           {
               nodeCount = 0;
               return 0;
           }

           //
           Int32 nodeCounter = 0;
           Int32 depth = 1;
           Root.Depth = 1;
           Int32 maxDepth = depth;

           Stack<BinTreeNode<T>> stack = new Stack<BinTreeNode<T>>();

           do
           {
               while (tempNode != null)
               {
                   nodeCounter++;
                   if (tempNode.LeftChild != null)
                   {
                       tempNode.LeftChild.Depth = tempNode.Depth + 1;
                   }

                   maxDepth = Math.Max(maxDepth, tempNode.Depth);
                   Console.WriteLine(tempNode.Value.ToString());
                   stack.Push(tempNode);
                   tempNode = tempNode.LeftChild;
               }

               BinTreeNode<T> pop = stack.Pop();

               if (pop.RightChild != null)
               {
                   pop.RightChild.Depth = pop.Depth + 1;
               }

               tempNode = pop.RightChild;
           }
           while (stack.Count > 0 || tempNode != null);

           nodeCount = nodeCounter;
           return maxDepth;
       }