平衡二叉树（AVL树）

平衡二叉树

或者是一颗空树，或者它的左右子树都是平衡二叉树，且左子树和右子树的深度之差不超过1 。

BF（Balance Factor）

我们将二叉树上节点的左子树深度减去右子树深度的值成为平衡因子。那么平衡二叉树上所有节点的平衡因子只可能是-1,0,1.只要二叉树上有一个节点的平衡引子的绝对值大于1，则该二叉树就是不平衡的。

距离插入节点最近的，且平衡因子的绝对值大于1的节点为根的子树，我们成为最小不平衡子树。最小不平衡子树的树根是我们操作平衡转换的参照点，调整最小不平衡子树，然后就可以达到平衡的效果。

 

首先要明白，如果需要调整平衡二叉树，那么这颗二叉树肯定是刚刚开始不平衡的，我们只需要调整因为插入新节点导致的最小不平衡子树的结构即可。

树的节点结构，相比于二叉查找树，增加一bf，用来存储平衡因子。

 

[cpp] ​​view plain​​ ​​copy​​

 

2. /* 二叉树的二叉链表节点结构定义 */  
3. typedef struct BiTNode  
4. {  
5.     int data;     
6.     int bf;                         /* 相对于二叉查找树，增加了平衡因子bf */  
7.     struct BiTNode *lchild, *rchild;  
8. } BiTNode, *BiTree;  

两个基本操作，左旋和右旋。

 

右旋图示：

代码如下：

 

 

[cpp] ​​view plain​​ ​​copy​​

 

2. /* 对以p为根的二叉排序树作右旋处理 */  
3. /* 处理之后p指向新的树根节点，即旋转处理之前的左子树的根节点 */  
4. void R_Rotate( BiTree *p )  
5. {  
6.     /* 
7.       L->rchild (节点2的右孩子) 为NULL          L->rchild != NULL 
8.       例 :    3                                例 ：  9              6  
9.              /                                       / \            / \ 
10.             2    =>    2                            6  10   =>     5   9 
11.            /          / \                          / \            /   / \ 
12.           1          1   3                        5   7          4   7  10 
13.                                                  / 
14.                                                 4 
15.     */  
16.     BiTree L;  
17.     L = (*p)->lchild;  
18.     (*p)->lchild = L->rchild; /* 容易忽视，将*p的左子树的右子树作为*p的左子树（如果 L->rchild 不为空） */  
19.     L->rchild = (*p);  
20.     *p = L;  
21. }  

 

左旋图示：

 

代码如下：

 

[cpp] ​​view plain​​ ​​copy​​

 

2. /* 对以p为根的二叉排序树作左旋处理 */  
3. /* 处理之后 p 指向新的树根节点，即旋转处理之前的右子树的根节点  */  
4. void L_Rotate( BiTree *p)  
5. {  
6.     /* 
7.       R->lchild (节点2的左孩子) 为NULL          R->lchild != NULL 
8.       例 :   1                                例 ：   9                15  
9.               \                                      / \              /  \ 
10.                2    =>    2                         6  15     =>     9    17  
11.                 \        / \                           / \          / \   / 
12.                  3      1   3                        10   17       6  10 16   
13.                                                           / 
14.                                                          16 
15.     */  
16.     BiTree R;  
17.     R = (*p)->rchild;          
18.     (*p)->rchild = R->lchild;     /* 将 P 的右孩子的左孩子转接到 p 的右孩子上，上述的将 10 接至 9 的右孩子上 */  
19.     R->lchild = *p;  
20.     *p = R;  
21. }  

 

 

两个复杂调整：

2. 右子树插入新节点，导致不平衡，但是不能够通过简单的左旋、右旋解决。
   由于插入节点 8 导致出现了最小不平衡子树（树根为 6 ），于是现将以 9 为根的树右旋处理，达到图15效果，然后，在将以 6 为根的树左旋处理，最后二叉树重新平衡，达到图16的效果。 

代码如下：

 

[cpp] ​​view plain​​ ​​copy​​

 

2. /* 右平衡处理 */  
3. /* 对以指针T所指节点为根的二叉树作右平衡旋转处理，与左平衡相对 */  
4. /* 本算法结束时，指针T指向新的根节点 */  
5. /* 参照左平衡处理的图示分析 */  
6. void RightBalance( BiTree *T )  
7. {  
8.     BiTree R, Rl;  
9.     R = (*T)->rchild;  
10.     switch( R->bf )  
11.     {  
12.     case RH:  
13.         (*T)->bf = R->bf = EH;  
14.         L_Rotate(T);  
15.         break;  
16.     case LH:  
17.         Rl = R->lchild;  
18.         switch( Rl->bf )  
19.         {  
20.         case LH:  
21.             (*T)->bf = EH;  
22.             R->bf = RH;  
23.             break;  
24.         case EH:  
25.             (*T)->bf = R->bf = EH;  
26.         case RH:  
27.             (*T)->bf = LH;  
28.             R->bf = EH;  
29.             break;  
30.         }  
31.         Rl->bf = EH;  
32.         R_Rotate( &(*T)->rchild );  
33.         L_Rotate( T );    
34.     }  
35. }  

 

  2. 另一种复杂情况是在左子树上插入了新节点，导致不平衡，于是先左旋、再右旋。详见代码。

    代码如下：

 

[cpp] ​​view plain​​ ​​copy​​

 

2. /* 左平衡旋转处理的函数代码 */  
3. /* 对以指针T所指节点为根的二叉树作左平衡旋转处理 */  
4. /* 本算法结束时，指针T指向新的根节点 */  
5. /* 注意：函数被调用，传入一个需要调整平衡性的子树T。由于LeftBalance函数被调用时候 */  
6. /* 其实是已经确认当前子树是不平衡状态，且左子树高度大于右子树高度。 */  
7. /* 换句话说，此时T的根节点应该是平衡因子BF的值大于 1 的数 */  
8. void LeftBalance( BiTree *T )  
9. {  
10.     BiTree L, Lr;  
11.     L = (*T)->lchild;    /* L指向T的左子树根节点 */  
12.     switch( L->bf )  
13.     {  
14.         /* 检查T的左子树的平衡度，并做相应的平衡处理 */  
15.     case LH:    /* 新节点插入在T的左孩子的左子树上，要作单向右旋处理 */  
16.         /* 
17.                 8(*T)                  5                   8                            5 
18.                / \                    / \                 / \                         /  \ 
19.            (L)5   9                  4   8      or       5   9                       4    8 
20.              / \     =>(直接右旋)   /   / \             / \         =>(直接右旋)      \  / \ 
21.             4   6                  3   6   9           4   6                           3 6  9 
22.            /                                            \  
23.           3(新插入)                                      3(新插入)  
24.            
25.         */  
26.         (*T)->bf = L->bf = EH;  
27.         R_Rotate( T );  
28.         break;  
29.     case RH:    /* 新节点插入在T的左孩子的右子树上，要做双旋处理 */  
30.         Lr = L->rchild;  
31.         switch( Lr->bf )  
32.         {  
33.         case LH:  
34.             /* 
35.                     8                                     8                                     7 
36.                    / \                                   / \                                  /  \ 
37.                   5   9                                 7   9                                5    8 
38.                  / \        =>(先以5为根，单向左旋)    /          =>(以8为根，单向右旋)     / \    \ 
39.                 4   7                                 5                                    4   6    9 
40.                    /                                 / \  
41.                   6                                 4   6   
42.             */  
43.             (*T)->bf = RH;  
44.             L->bf = EH;  
45.             break;  
46.         case EH:  
47.             (*T)->bf = L->bf = EH;  
48.             break;  
49.         case RH:  
50.             /*  
51.                     8                                     8                                     6 
52.                    / \                                   / \                                   / \ 
53.                   5   9                                 6   9                                 5   8 
54.                  / \        =>(先以5为跟，单向左旋)    / \         =>(以8为跟，单向右旋)     /   / \  
55.                 4   6                                 5   7                                 4   7   9 
56.                      \                               /    
57.                       7                             4 
58.             */  
59.             (*T)->bf = EH;  
60.             L->bf = LH;  
61.             break;  
62.         }  
63.         Lr->bf = EH;  
64.         L_Rotate( &(*T)->lchild );  
65.         R_Rotate( T );  
66.     }  
67. }  

 

插入：（Insert_AVL）

    插入函数结合了上面的做右平衡处理的方法，现在平衡二叉树中查找是否已经存在该元素，如果已经存在，那么不插入，否则，插入新节点，再通过对应的处理，使二叉树保持平衡状态，更新每个结点的平衡因子。

[cpp] ​​view plain​​ ​​copy​​

 

2. /* 若在平衡的二叉排序树T中不存在和e有相同关键字的节点，则插入一个 */  
3. /* 数据元素为e的新节点并返回1，否则返回0 。若因插入而使二叉排序树 */  
4. /* 失去平衡，则作平衡旋转处理，布尔变量taller反应T是否长高 */  
5. int Insert_AVL( BiTree *T, int e, int *taller)  
6. {  
7.     if( !(*T) )  
8.     {  
9.         /* 递归调用Insert_AVL函数，如果进入if语句，说明原二叉排序树中不存在与e相等的结点 */  
10.         /* 故而，插入新结点，树“长高”，置taller为TRUE */  
11.         *T = ( BiTree )malloc( sizeof(BiTNode) );  
12.         ( *T )->data = e;  
13.         ( *T )->lchild = ( *T )->rchild = NULL;  
14.         ( *T )->bf = EH;  
15.         *taller = TRUE;  
16.     }     
17.     else  
18.     {  
19.         if( e == (*T)->data )  
20.         {  
21.             /* 书中已存在与e相等的节点，不需要再次插入 */  
22.             *taller = FALSE;  
23.             return FALSE;  
24.         }  
25.         else if( e < (*T)->data )  
26.         {  
27.             /* 应该继续在T的左子树中进行搜索 */  
28.             if( !Insert_AVL( &(*T)->lchild, e, taller) )       
29.                 /*  说明插入失败，已经存在与e相等的节点，无需再次插入 */  
30.                 return FALSE;  
31.             if(*taller)   
32.             {  
33.                 /* 已经插入到 T 的左子树，且左子树“长高” */  
34.                 switch( (*T)->bf )  
35.                 {  
36.                 case LH:      
37.                     /* 原本左子树比右子树高，则需要进行平衡处理 */  
38.                     LeftBalance(T);  
39.                     *taller = FALSE;  
40.                     break;  
41.                 case EH:  
42.                     /* 原本左右子树等高，现因左子树增高而树增高 */  
43.                     (*T)->bf = LH;  
44.                     *taller = TRUE;  
45.                     break;  
46.                 case RH:  
47.                     /* 原本右子树比左子树高，现左右子树等高 */  
48.                     (*T)->bf = EH;  
49.                     *taller = FALSE;  
50.                     break;  
51.                 }  
52.             }  
53.         }  
54.         else  
55.         {  
56.             /* 应该继续在T的右子树中进行搜索 */  
57.             if( !Insert_AVL( &(*T)->rchild, e, taller) )       
58.                 /*  说明插入失败，已经存在与e相等的节点，无需再次插入 */  
59.                 return FALSE;  
60.             if(*taller)  
61.             {  
62.                 /* 已经插入到 T 的右子树且右子树“长高” */  
63.                 switch( (*T)->bf )  
64.                 {  
65.                     /* 检查 T 的平衡度 */  
66.                 case LH:  
67.                      (*T)->bf = EH;  
68.                      *taller = FALSE;  
69.                     break;   
70.                 case EH:  
71.                     (*T)->bf = RH;  
72.                     *taller = TRUE;  
73.                     break;  
74.                 case RH:  
75.                     RightBalance(T);  
76.                     *taller = FALSE;  
77.                     break;  
78.                 }  
79.             }  
80.         }  
81.     }  
82.     return TRUE;  
83. }  

完整代码：

 

[cpp] ​​view plain​​ ​​copy​​

 

2. #include<stdio.h>  
3. #define LH +1   /* 左高 */  
4. #define EH 0    /* 等高 */  
5. #define RH -1   /* 右高 */  
6. #define TRUE 1  
7. #define FALSE 0  
8.   
9. /* 二叉树的二叉链表节点结构定义 */  
10. typedef struct BiTNode  
11. {  
12.     int data;     
13.     int bf;                         /* 相对于二叉查找树，增加了平衡因子bf */  
14.     struct BiTNode *lchild, *rchild;  
15. } BiTNode, *BiTree;  
16.   
17. void order(BiTree t)//中序输出    
18. {    
19.     if(t == NULL)    
20.         return ;    
21.     order(t->lchild);    
22.     printf("%d ", t->data);    
23.     order(t->rchild);    
24. }   
25.   
26. /* 对以p为根的二叉排序树作右旋处理 */  
27. /* 处理之后p指向新的树根节点，即旋转处理之前的左子树的根节点 */  
28. void R_Rotate( BiTree *p )  
29. {  
30.     /* 
31.       L->rchild (节点2的右孩子) 为NULL          L->rchild != NULL 
32.       例 :    3                                例 ：  9              6  
33.              /                   / \            / \ 
34.             2    =>    2                            6  10   =>     5   9 
35.            /          / \                          / \            /   / \ 
36.           1          1   3                        5   7          4   7  10 
37.                                                  / 
38.                                 4 
39.     */  
40.     BiTree L;  
41.     L = (*p)->lchild;  
42.     (*p)->lchild = L->rchild; /* 容易忽视，将*p的左子树的右子树作为*p的左子树（如果 L->rchild 不为空） */  
43.     L->rchild = (*p);  
44.     *p = L;  
45. }  
46.   
47. /* 对以p为根的二叉排序树作左旋处理 */  
48. /* 处理之后 p 指向新的树根节点，即旋转处理之前的右子树的根节点  */  
49. void L_Rotate( BiTree *p)  
50. {  
51.     /* 
52.       R->lchild (节点2的左孩子) 为NULL          R->lchild != NULL 
53.       例 :   1                                例 ：   9                15  
54.               \                          / \              /  \ 
55.                2    =>    2                         6  15     =>     9    17  
56.                 \        / \                           / \          / \   / 
57.                  3      1   3                        10   17       6  10 16   
58.                                                           / 
59.                                      16 
60.     */  
61.     BiTree R;  
62.     R = (*p)->rchild;          
63.     (*p)->rchild = R->lchild;     /* 将 P 的右孩子的左孩子转接到 p 的右孩子上，上述的将 10 接至 9 的右孩子上 */  
64.     R->lchild = *p;  
65.     *p = R;  
66. }  
67.   
68. /* 左平衡旋转处理的函数代码 */  
69. /* 对以指针T所指节点为根的二叉树作左平衡旋转处理 */  
70. /* 本算法结束时，指针T指向新的根节点 */  
71. /* 注意：函数被调用，传入一个需要调整平衡性的子树T。由于LeftBalance函数被调用时候 */  
72. /* 其实是已经确认当前子树是不平衡状态，且左子树高度大于右子树高度。 */  
73. /* 换句话说，此时T的根节点应该是平衡因子BF的值大于 1 的数 */  
74. void LeftBalance( BiTree *T )  
75. {  
76.     BiTree L, Lr;  
77.     L = (*T)->lchild;    /* L指向T的左子树根节点 */  
78.     switch( L->bf )  
79.     {  
80.         /* 检查T的左子树的平衡度，并做相应的平衡处理 */  
81.     case LH:    /* 新节点插入在T的左孩子的左子树上，要作单向右旋处理 */  
82.         /* 
83.             8(*T)                  5                   8                            5 
84.                / \                    / \                 / \                         /  \ 
85.            (L)5   9                  4   8      or       5   9                       4    8 
86.              / \     =>(直接右旋)   /   / \             / \         =>(直接右旋)      \  / \ 
87.             4   6                  3   6   9           4   6                           3 6  9 
88.            /                                            \  
89.           3(新插入)                                      3(新插入)  
90.            
91.         */  
92.         (*T)->bf = L->bf = EH;  
93.         R_Rotate( T );  
94.         break;  
95.     case RH:    /* 新节点插入在T的左孩子的右子树上，要做双旋处理 */  
96.         Lr = L->rchild;  
97.         switch( Lr->bf )  
98.         {  
99.         case LH:  
100.             /* 
101.                 8                                     8                                     7 
102.                    / \                                   / \                                  /  \ 
103.                   5   9                                 7   9                                5    8 
104.                  / \        =>(先以5为根，单向左旋)    /          =>(以8为根，单向右旋)     / \    \ 
105.                 4   7                                 5                                    4   6    9 
106.                    /                                 / \  
107.                   6                                 4   6   
108.             */  
109.             (*T)->bf = RH;  
110.             L->bf = EH;  
111.             break;  
112.         case EH:  
113.             (*T)->bf = L->bf = EH;  
114.             break;  
115.         case RH:  
116.             /*  
117.                 8                                     8                                     6 
118.                    / \                                   / \                                   / \ 
119.                   5   9                                 6   9                                 5   8 
120.                  / \        =>(先以5为跟，单向左旋)    / \         =>(以8为跟，单向右旋)     /   / \  
121.                 4   6                                 5   7                                 4   7   9 
122.                      \                               /    
123.                       7                             4 
124.             */  
125.             (*T)->bf = EH;  
126.             L->bf = LH;  
127.             break;  
128.         }  
129.         Lr->bf = EH;  
130.         L_Rotate( &(*T)->lchild );  
131.         R_Rotate( T );  
132.     }  
133. }  
134.   
135. /* 右平衡处理 */  
136. /* 对以指针T所指节点为根的二叉树作右平衡旋转处理，与左平衡相对 */  
137. /* 本算法结束时，指针T指向新的根节点 */  
138. /* 参照左平衡处理的图示分析 */  
139. void RightBalance( BiTree *T )  
140. {  
141.     BiTree R, Rl;  
142.     R = (*T)->rchild;  
143.     switch( R->bf )  
144.     {  
145.     case RH:  
146.         (*T)->bf = R->bf = EH;  
147.         L_Rotate(T);  
148.         break;  
149.     case LH:  
150.         Rl = R->lchild;  
151.         switch( Rl->bf )  
152.         {  
153.         case LH:  
154.             (*T)->bf = EH;  
155.             R->bf = RH;  
156.             break;  
157.         case EH:  
158.             (*T)->bf = R->bf = EH;  
159.         case RH:  
160.             (*T)->bf = LH;  
161.             R->bf = EH;  
162.             break;  
163.         }  
164.         Rl->bf = EH;  
165.         R_Rotate( &(*T)->rchild );  
166.         L_Rotate( T );    
167.     }  
168. }  
169.   
170. /* 若在平衡的二叉排序树T中不存在和e有相同关键字的节点，则插入一个 */  
171. /* 数据元素为e的新节点并返回1，否则返回0 。若因插入而使二叉排序树 */  
172. /* 失去平衡，则作平衡旋转处理，布尔变量taller反应T是否长高 */  
173. int Insert_AVL( BiTree *T, int e, int *taller)  
174. {  
175.     if( !(*T) )  
176.     {  
177.         /* 递归调用Insert_AVL函数，如果进入if语句，说明原二叉排序树中不存在与e相等的结点 */  
178.         /* 故而，插入新结点，树“长高”，置taller为TRUE */  
179.         *T = ( BiTree )malloc( sizeof(BiTNode) );  
180.         ( *T )->data = e;  
181.         ( *T )->lchild = ( *T )->rchild = NULL;  
182.         ( *T )->bf = EH;  
183.         *taller = TRUE;  
184.     }     
185.     else  
186.     {  
187.         if( e == (*T)->data )  
188.         {  
189.             /* 书中已存在与e相等的节点，不需要再次插入 */  
190.             *taller = FALSE;  
191.             return FALSE;  
192.         }  
193.         else if( e < (*T)->data )  
194.         {  
195.             /* 应该继续在T的左子树中进行搜索 */  
196.             if( !Insert_AVL( &(*T)->lchild, e, taller) )       
197.                 /*  说明插入失败，已经存在与e相等的节点，无需再次插入 */  
198.                 return FALSE;  
199.             if(*taller)   
200.             {  
201.                 /* 已经插入到 T 的左子树，且左子树“长高” */  
202.                 switch( (*T)->bf )  
203.                 {  
204.                 case LH:      
205.                     /* 原本左子树比右子树高，则需要进行平衡处理 */  
206.                     LeftBalance(T);  
207.                     *taller = FALSE;  
208.                     break;  
209.                 case EH:  
210.                     /* 原本左右子树等高，现因左子树增高而树增高 */  
211.                     (*T)->bf = LH;  
212.                     *taller = TRUE;  
213.                     break;  
214.                 case RH:  
215.                     /* 原本右子树比左子树高，现左右子树等高 */  
216.                     (*T)->bf = EH;  
217.                     *taller = FALSE;  
218.                     break;  
219.                 }  
220.             }  
221.         }  
222.         else  
223.         {  
224.             /* 应该继续在T的右子树中进行搜索 */  
225.             if( !Insert_AVL( &(*T)->rchild, e, taller) )       
226.                 /*  说明插入失败，已经存在与e相等的节点，无需再次插入 */  
227.                 return FALSE;  
228.             if(*taller)  
229.             {  
230.                 /* 已经插入到 T 的右子树且右子树“长高” */  
231.                 switch( (*T)->bf )  
232.                 {  
233.                     /* 检查 T 的平衡度 */  
234.                 case LH:  
235.                      (*T)->bf = EH;  
236.                      *taller = FALSE;  
237.                     break;   
238.                 case EH:  
239.                     (*T)->bf = RH;  
240.                     *taller = TRUE;  
241.                     break;  
242.                 case RH:  
243.                     RightBalance(T);  
244.                     *taller = FALSE;  
245.                     break;  
246.                 }  
247.             }  
248.         }  
249.     }  
250.     return TRUE;  
251. }  
252.   
253.   
254. void main()  
255. {  
256.     int i;  
257.     int a[] = {3,2,1,4,5,6,7,10,9,8};  
258.     BiTree T = NULL;  
259.     int taller;  
260.     for( i = 0; i < 10; i++)  
261.         Insert_AVL(&T, a[i], &taller);    
262.     order(T);  
263.     printf("\n");  
264. }  

 

 

总结，待续……

作者：​​柒月​​​​​​​​