数据结构BinaryTree实例（五)：树的深度与广度

    树的深度指的是树的层数，树的广度指的是每一层上结点最多的数，前者可以用递归或者栈求得，后者可以用队列辅助得到，在本例中，求树的广度时也同样可以获取树的深度。

/**  

*@Title: DepthAndWidth.java

*@Package binarytree

*@Description: TODO

*@author peidong 

*@date 2017-5-11 上午9:03:19

*@version V1.0  

*/

packagebinarytree;

 

importjava.util.ArrayDeque;

importjava.util.LinkedList;

importjava.util.Queue;

 

importbinarytree.Ancestors.TreeNode;

 

/**

 * @ClassName: DepthAndWidth

 * @Description: 求二叉树的深度和宽度

 * @date 2017-5-11 上午9:03:19

 * 

 */

publicclass DepthAndWidth {

 

       /**

        *

       * @ClassName: TreeNode

       * @Description: 树的结点

       * @date 2017-5-11 上午9:03:52

       *

        */

       public static class TreeNode{

              public int data;

              public TreeNode left;

              public TreeNode right;

             

              public TreeNode(int data){

                     this.data = data;

                     left = null;

                     right = null;

              }

       }

      

       /**

        * 这个可以使用递归，分别求出左子树的深度、右子树的深度，两个深度的较大值+1即可。

       * @Title: getMaxTreeDepth

       * @Description: 递归获取树的深度

       * @param root

       * @return   

       * @return int   

       * @throws

        */

       public static intgetMaxTreeDepth(TreeNode root){

              //树为空

              if(root == null)

                     return 0;

              else{

                     int left =getMaxTreeDepth(root.left); //获取左子树深度

                     int right =getMaxTreeDepth(root.right); //获取右子树深度

                     return 1 + Math.max(left,right);

              }

       }

      

       /**

        *

       * @Title: getMaxTreeWidth

       * @Description: 利用队列获取树的最大宽度

       * @param root

       * @return   

       * @return int   

       * @throws

        */

       private static int levelNum = 0;   //树的深度

       public static intgetMaxTreeWidth(TreeNode root){

              //如果树为空

              if(root == null)

                     return 0;

             

              //初始化队列，存储每一层的结点

              Queue<TreeNode> queue = newArrayDeque<TreeNode>();

             

              //初始化最大宽度

              int maxWidth = 1;

             

              //根节点入队

              queue.add(root);

             

              while (true) {

                     int len = queue.size(); // 当前层的节点个数

                     if (len == 0)

                            break;

                     while (len > 0) {// 如果当前层，还有节点

                            TreeNode t =queue.poll();  //出队

                            len--;

                            if(len == 0)

                                   levelNum++;   //len为0，则代表本层遍历完了，层数+1

                            if (t.left !=null)  // 左子树存在，入队

                                   queue.add(t.left);

                            if (t.right !=null)  // 右子树存在，入队

                                   queue.add(t.right);

                     }

                     maxWidth =Math.max(maxWidth, queue.size());

              }

              return maxWidth;

       }

             

             

       /**

        *@Title: main

        *@Description: 测试用例

        *@param args   

        *@return void   

        *@throws

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

             

              //构建树

              TreeNode root = new TreeNode(1);

              root.left = new TreeNode(2);

              root.right = new TreeNode(3);

              root.left.left = new TreeNode(4);

              root.left.right = new TreeNode(5);

              root.right.left = new TreeNode(6);

              root.right.right = new TreeNode(8);

              root.left.left.left = newTreeNode(7);

              root.left.left.left.left = newTreeNode(10);

              root.left.left.left.left.left =new TreeNode(11);

             

              System.out.println("树的深度为：" +getMaxTreeDepth(root));

              System.out.println("树的宽度为：" +getMaxTreeWidth(root));

              System.out.println("数的深度为："+ levelNum);

       }

}