二叉树的深度（递归和非递归）---java实现

https://blog.youkuaiyun.com/snow_7/article/details/51818580

递归实现

为了求树的深度，可以先求其左子树的深度和右子树的深度，可以用递归实现，递归的出口就是节点为空。返回值为0；

非递归实现

利用层次遍历的算法，设置变量level记录当前节点所在的层数，设置变量last指向当前层的最后一个节点，当处理完当前层的最后一个节点，让level指向+1操作。设置变量cur记录当前层已经访问的节点的个数，当cur等于last时，表示该层访问结束。

层次遍历在求树的宽度、输出某一层节点，某一层节点个数，每一层节点个数都可以采取类似的算法。

树的宽度：在树的深度算法基础上，加一个记录访问过的层节点个数最多的变量max,在访问每层前max与last比较，如果max比较大，max不变，如果max小于last，把last赋值给max;

代码：

[java]  view plain  copy

1. import java.util.LinkedList;  
2.   
3. public class Deep  
4. {  
5.     //递归实现1  
6.   public int findDeep(BiTree root)  
7.   {  
8.       int deep = 0;  
9.       if(root != null)  
10.       {  
11.           int lchilddeep = findDeep(root.left);  
12.           int rchilddeep = findDeep(root.right);  
13.           deep = lchilddeep > rchilddeep ? lchilddeep + 1 : rchilddeep + 1;  
14.       }  
15.       return deep;  
16.   }  
17.     
18.     
19.   //递归实现2  
20.   public int findDeep1(BiTree root)  
21.   {  
22.       
23.       if(root == null)  
24.       {  
25.           return 0;  
26.       }  
27.       else  
28.       {  
29.        int lchilddeep = findDeep1(root.left);//求左子树的深度  
30.        int rchilddeep = findDeep1(root.left);//求右子树的深度  
31.        return lchilddeep > rchilddeep ? lchilddeep + 1 : rchilddeep + 1;//左子树和右子树深度较大的那个加一等于整个树的深度  
32.       }  
33.   }  
34.     
35.     
36.   //非递归实现  
37.   public int findDeep2(BiTree root)  
38.   {  
39.      if(root == null)  
40.          return 0;  
41.       
42.      BiTree current = null;  
43.      LinkedList<BiTree> queue = new LinkedList<BiTree>();  
44.      queue.offer(root);  
45.      int cur,last;  
46.      int level = 0;  
47.      while(!queue.isEmpty())  
48.      {  
49.          cur = 0;//记录本层已经遍历的节点个数  
50.          last = queue.size();//当遍历完当前层以后，队列里元素全是下一层的元素，队列的长度是这一层的节点的个数  
51.          while(cur < last)//当还没有遍历到本层最后一个节点时循环  
52.          {  
53.              current = queue.poll();//出队一个元素  
54.              cur++;  
55.              //把当前节点的左右节点入队（如果存在的话）  
56.              if(current.left != null)  
57.              {  
58.                  queue.offer(current.left);  
59.              }  
60.              if(current.right != null)  
61.              {  
62.                  queue.offer(current.right);  
63.              }  
64.          }  
65.          level++;//每遍历完一层level+1  
66.      }  
67.      return level;  
68.   }  
69.   public static void main(String[] args)  
70.  {  
71.     BiTree root = BiTree.buildTree();  
72.     Deep deep = new Deep();  
73.     System.out.println(deep.findDeep(root));  
74.     System.out.println(deep.findDeep1(root));  
75.     System.out.println(deep.findDeep2(root));     
76.  }  
77. }  

树的结构

                   A

             /              \

           B               C

         /    \                 \

       D     E               G