實現一個函數，檢查二叉樹是否平衡。

二叉樹平衡的定義以下：任意一個結點，其兩顆子樹的高度差不超過1

遞歸訪問每一個整棵樹，計算每一個結點子樹的高度

 

[java] view plain copy

 

1. public class BTreeBalanced {  
2.     static class TreeNode {  
3.         int data;  
4.         static TreeNode left;  
5.         static TreeNode right;  
6.     }  
7.     public static boolean isBalanced(TreeNode root) {  
8.         if (null == root) return true;  
9.         int heightDiff = getHeight(root.left) - getHeight(root.right);  
10.         if ( Math.abs(heightDiff)  > 1 ) {  
11.             return false;  
12.         }  
13.         else {  
14.             return ( isBalanced(TreeNode.left) && isBalanced(TreeNode.right) );  
15.         }  
16.     }  
17.     public static int getHeight(TreeNode root) {  
18.         if (null == root) return 0;  
19.         return Math.max( getHeight(root.left), getHeight(root.right) + 1 );  
20.     }  
21. }  

但這樣作的效率不高，getHeight（）會被反覆調用計算同一個結點的高度，時間複雜度爲O（N logN）

 

getHeight（）其實不只能夠檢查高度，還能檢查樹是否平衡，只要將判斷左右子樹高度差是否大於一放進getHeight（）就能夠了，下面用checkHeight（）來表示這一段代碼。

這樣作的好處是時間複雜度下降了，爲O（N）,空間複雜度爲O（H），H爲樹的高度

 

[java] view plain copy

 

1. public static int checkHeight(TreeNode root) {  
2.         if (null == root) return 0;  
3.         int leftHeight = checkHeight(root.left);  
4.         if ( leftHeight == -1 ) {  
5.             return -1; //unbalanced  
6.         }  
7.           
8.         int rightHeight = checHeight(root.right);  
9.         if ( rightHeight == -1 ) {  
10.             return -1; //unbalanced  
11.         }  
12.           
13.         int heightDiff = leftHeight - rightHeight;  
14.         if (Math.abs(heightDiff) > 1) {  
15.             return -1; // unbalanced  
16.         }  
17.         else {  
18.             return Math.max( rightHeight, rightHeight + 1 );  
19.         }  
20.     }  
21.     public static boolean isBalanced2(TreeNode root) {  
22.         if(checkHeight(root) == -1) {  
23.             return false;  
24.         }  
25.         else {  
26.             return true;  
27.         }  
28.     } 

或者：

1. int getHeight(Node node){  
2.    if(node==null){  
3.       return 0;  
4.    }  
5.    int heigth = 1;  
6.    if(node.left!=null){  
7.       height = 1+getHeight(node.left);  
8.   }  
9.    if(node.rigth!=null){  
10.       int h = 1+getHeight(node.right);  
11.       height = height>h?height:h;  
12.    }  
13.   return height;  
14. }  
15.   
16. boolean isBalance(Node node){  
17.    if(node==null){  
18.      return true;  
19.    }  
20.    int left = getHeight(node.left);  
21.    int right = getHeight(node.right);  
22.    int diff = left - right;  
23.     if(diff > 1 || diff < -1)  
24.         return false;  
25.    return isBalance(node.left)&&isBalance(node.right);  
26. }  

咱們用後序遍歷的方式遍歷二叉樹的每個結點，在遍歷到一個結點以前咱們已經遍歷了它的左右子樹。只要在遍歷每一個結點的時候記錄它的深度（某一結點的深度等於它到葉節點的路徑的長度），咱們就能夠一邊遍歷一邊判斷每一個結點是否是平衡的
 

Java代碼

 

1. boolean isBalance(Node node,Depth d){  
2.    if(node==null){  
3.       d.height=0;  
4.       return true;  
5.    }  
6.    Depth right=new Depth();  
7.    depth left = new Depth();  
8.    if(isBalance(node.left,left)&&isBalance(node.right,right)){  
9.        int diff = left.height-right.height;  
10.        if(diff<=1||diff>=-1){//絕對值小於等於1  
11.         //若是是平衡樹，纔有必要算深度，而後看上級是否是平衡樹  
12.           d.height=left.height>right.height?left.height:right.height;  
13.           return true  
14.        }  
15.    }  
16.    return false;  
17. }