1. 二叉平衡树的概念

   参见另一篇博客

2 如何判断一棵二叉树是平衡二叉树？

   思路：

       先编写计算二叉树高度的函数，然后再判断每个节点的左右子树是否相差1。

   代码如下：

//判断二叉树的高度

      template<typename T>

1. int DepthTree(BSTreeNode<T> *pbs)  
2. {  
3.     if (pbs==NULL)  
4.         return 0;  
5.     else  
6.     {  
7.         int leftLength=DepthTree(pbs->left);  
8.         int rigthLength=DepthTree(pbs->right);  
9.         return 1+(leftLength>rigthLength ? leftLength:rigthLength);  
10.     }  
11. }  

//判断二叉树是否是平衡二叉树（方法一）

1. template<typename T>  
2. bool isBalanceTree(BSTreeNode<T> *pbs)  
3. {  
4.     if (pbs==NULL)  
5.     {  
6.         return true;  
7.     }  
8.       
9.     int depthLeft=DepthTree(pbs->left);  
10.     int depthRight=DepthTree(pbs->right);  
11.       
12.     if (abs(depthLeft-depthRight)>1)   
13.          return false;  
14.     else  
15.         return isBalanceTree(pbs->left) && isBalanceTree(pbs->right);  
16. } 

//判断二叉树是否是平衡二叉树（方法二）

1. template<typename T>  
2. bool isBalanceTree(BSTreeNode<T> *pbs， int *pDepth)  
3. {  
4.     if (pbs==NULL)  
5.     {  
6.         *pDepth = 0;
7.         return true;  
8.     }  
9.     int left, right ;
11.     if (isBalanceTree(pbs->left,&left) && isBalanceTree(pbs->right,&right))    
12.     {
13.       int dift = left – right;
14.       if(dift <=1 && dift >= -1)
15.       {
16.            *pDepth = 1 + （left > right ? left : right ）;
17.            return true;
18.        }
19.      }
20.      return false;  
22. } 

: 方法一中一个节点要被重复遍历多次，时间效率不高；方法二使用了后序遍历的方法，只要遍历到一个节点之前我们已经遍历了它的左右子树。（参见剑指offer）

  测试代码：

2. #include<iostream>  
3. #include<cmath>  
4. using namespace std;  
5.   
6. template<typename T>  
7. struct BSTreeNode  
8. {  
9.     T data;  
10.     BSTreeNode *left;  
11.     BSTreeNode *right;  
12. };  
13.   
14. template<typename T>  
15. int DepthTree(BSTreeNode<T> *pbs)  
16. {  
17.     if (pbs==NULL)  
18.         return 0;  
19.     else  
20.     {  
21.         int leftLength=DepthTree(pbs->left);  
22.         int rigthLength=DepthTree(pbs->right);  
23.         return 1+(leftLength>rigthLength ? leftLength:rigthLength);  
24.     }  
25. }  
26.   
27. template<typename T>  
28. bool isBalanceTree(BSTreeNode<T> *pbs)  
29. {  
30.     if (pbs==NULL)  
31.     {  
32.         return true;  
33.     }  
34.       
35.     int depthLeft=DepthTree(pbs->left);  
36.     int depthRight=DepthTree(pbs->right);  
37.       
38.     if (abs(depthLeft-depthRight)>1)   
39.          return false;  
40.     else  
41.         return isBalanceTree(pbs->left) && isBalanceTree(pbs->right);  
42. }  
43.   
44. void CreateTree1(BSTreeNode<int> *pHead)  
45. {  
46.      int m;  
47.      int i;  
48.      int rNum;                                                                                                                                                                                                          
49.        
50.      cin>>m;  
51.       
52.      BSTreeNode<int> *currentNode;  
53.      currentNode=pHead;  
54.      pHead->left=NULL;  
55.      pHead->right=NULL;  
56.   
57.      cin>>currentNode->data;  
58.         
59.      for(i=1;i<m;i++)  
60.      {     
61.          rNum=rand()%2;  
62.          if (rNum==0)  
63.          {  
64.              BSTreeNode<int> *leftNode;  
65.              leftNode=new BSTreeNode<int>;  
66.              cin>>leftNode->data;  
67.              leftNode->left=NULL;  
68.              leftNode->right=NULL;  
69.              currentNode->left=leftNode;  
70.              currentNode=leftNode;  
71.          }  
72.          else  
73.          {  
74.              BSTreeNode<int> *rightNode;  
75.              rightNode=new BSTreeNode<int>;  
76.              cin>>rightNode->data;  
77.              rightNode->right=NULL;  
78.              rightNode->left=NULL;  
79.              currentNode->right=rightNode;  
80.              currentNode=rightNode;  
81.          }  
82.      }  
83. }  
84.   
85. void CreateTree2(BSTreeNode<int> *pHead)  
86. {  
87.     int m;  
88.     cin>>m;  
89.     cin>>pHead->data;  
90.     pHead->left=NULL;  
91.     pHead->right=NULL;  
92.     int i;  
93.     BSTreeNode<int> *pCurrent;  
94.     pCurrent=pHead;  
95.      
96.     for (i=1;i<m;i++)  
97.     {   
98.        BSTreeNode<int> *pTemp;  
99.        pTemp=new BSTreeNode<int>;  
100.        pTemp->left=NULL;  
101.        pTemp->right=NULL;  
102.        cin>>pTemp->data;  
103.        pCurrent->left=pTemp;  
104.        pCurrent=pCurrent->left;  
105.     }  
106.       
107.     pCurrent=pHead;  
108.     while (pCurrent!=NULL)  
109.     {  
110.         cout<<pCurrent->data;  
111.         pCurrent=pCurrent->left;  
112.     }  
113. }  
114.   
115. int main()  
116. {  
117.       
118.     BSTreeNode<int> *head=NULL;  
119.   
120.     head=new BSTreeNode<int>;  
121.     CreateTree1(head);  
122.     //CreateTree2(head);  
123.     if (isBalanceTree(head))  
124.     {  
125.         cout<<“It is a Balance Tree!”<<endl;  
126.     }else  
127.     {  
128.         cout<<“The tree is not Balance!”<<endl;  
129.     }  
130.     return 0;  
131. }