AVL树及C语言实现

概念

 

平衡二叉树(Balanced binary tree)是由苏联数学家Adelson-Velskii and Landis于1962年首先提出的，所以又称为AVL树。

定义：平衡二叉树或为空树,或满足如下性质的二叉树:

 （1）本身首先是一棵二叉搜索树

  （2）左右子树深度之差的绝对值不超过1;

  （3）左右子树仍然为平衡二叉树.

平衡因子BF=左子树深度－右子树深度.

平衡二叉树每个结点的平衡因子只能是1，0，-1。若其绝对值超过1，则该二叉排序树就是不平衡的。
通过下面幅图可以看出，平衡二叉树可以保证最差查找效率为O(logN),而二叉查找树的最差查找效率为O(N)。

 

插入节点的调整方法

 

若向平衡二叉树中插入一个节点后破坏了平衡二叉树的平衡性，首先从根节点到该新插入节点的路径之逆向根节点方向找到第一个失去平衡的节点，然后以该失衡节点和它相邻的刚查找过的两个节点构成调整子树，使之成为新的平衡子树。当失去平衡的最小子树被调整为平衡子树后，原来其他所有不平衡子树无需调整，整个二叉排序树就又成了一个平衡二叉树。

失去平衡的最小子树是指以离插入节点最近，且平衡因子绝对值大于1的节点作为根的子树。

 （1）LL型平衡旋转法
由于在A的左孩子B的左子树上插入结点F，使A的平衡因子由1增至2而失去平衡。故需进行一次顺时针旋转操作。 即将A的左孩子B向右上旋转代替A作为根结点，A向右下旋转成为B的右子树的根结点。而原来B的右子树则变成A的左子树。

（2）RR型平衡旋转法
由于在A的右孩子C 的右子树上插入结点F，使A的平衡因子由-1减至-2而失去平衡。故需进行一次逆时针旋转操作。即将A的右孩子C向左上旋转代替A作为根结点，A向左下旋转成为C的左子树的根结点。而原来C的左子树则变成A的右子树。

（3）LR型平衡旋转法
由于在A的左孩子B的右子数上插入结点F，使A的平衡因子由1增至2而失去平衡。故需进行两次旋转操作（先逆时针，后顺时针）。即先将A结点的左孩子B的右子树的根结点D向左上旋转提升到B结点的位置，然后再把该D结点向右上旋转提升到A结点的位置。即先使之成为LL型，再按LL型处理。

如图中所示，即先将圆圈部分先调整为平衡树，然后将其以根结点接到A的左子树上，此时成为LL型，再按LL型处理成平衡型。

（4）RL型平衡旋转法 

由于在A的右孩子C的左子树上插入结点F，使A的平衡因子由-1减至-2而失去平衡。故需进行两次旋转操作（先顺时针，后逆时针），即先将A结点的右孩子C的左子树的根结点D向右上旋转提升到C结点的位置，然后再把该D结点向左上旋转提升到A结点的位置。即先使之成为RR型，再按RR型处理。

如图中所示，即先将圆圈部分先调整为平衡树，然后将其以根结点接到A的左子树上，此时成为RR型，再按RR型处理成平衡型。

平衡化靠的是旋转。参与旋转的是3个节点（其中一个可能是外部节点NULL），旋转就是把这3个节点转个位置。注意的是，左旋的时候p->right一定不为空，右旋的时候p->left一定不为空，这是显而易见的。

如果从空树开始建立，并时刻保持平衡，那么不平衡只会发生在插入删除操作上，而不平衡的标志就是出现bf == 2或者 bf == -2的节点。

 

删除节点的调整方法

在平衡二叉树上删除节点x（假定有且仅有一个节点等于x）的过程如下：

1、采用二叉排序树的删除方法找到节点x并删除之；

2、沿着根到被删除节点的路线之逆逐层向上查找，必要时修改x祖先节点的平衡因子，因为删除后会使得某些子树的高度降低；

3、查找途中，一旦发现x的某个祖先*p失衡，就要进行调整。不妨设x节点在*p的左子树中，在*p节点失衡后，要做何种调整，取决于*p节点的右孩子，*p1，若*p1的平衡因子是1，则做RL调整；若*p1的平衡因子是-1，则做RR调整；若*p1的平衡因子是0，则做RL或者RR调整均可。如果x在*p右子树中，调整过程类似。

4、如果调整后，子树的高度降低了，这个过程还要继续，直到根节点为止。即，删除一个节点可能会引起多次调整，而不是插入时的至多一次调整。

 

 节点查找

 

和二叉排序树完全相同。

 

C语言实现一

由于没有删除某一个节点的功能，故在数据结构的定义中没有提供父节点指针。

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <malloc.h>  
3.   
4. typedef enum  
5. {  
6.     EH = 0,  
7.     LH = 1,  
8.     RH = -1   
9. }bh_t;  
10.   
11.   
12. typedef enum  
13. {  
14.     FALSE = 0,  
15.     TRUE = 1  
16. }bool_t;  
17.   
18. typedef int ElemType;  
19.   
20. typedef struct BSTNode  
21. {  
22.     ElemType key;  
23.     int bf;  
24.     struct BSTNode *lchild,*rchild;  
25. }BSTNode,*BSTree;  
26.   
27.   
28. void InOrderTraverse(BSTree root)  
29. {  
30.     if(NULL != root)  
31.     {  
32.         InOrderTraverse(root->lchild);  
33.         printf("%d\t",root->key);  
34.         InOrderTraverse(root->rchild);  
35.     }  
36. }  
37.   
38.   
39. void PreOrderTraverse(BSTree root)  
40. {  
41.     if(NULL != root)  
42.     {  
43.         printf("%d\t",root->key);  
44.         PreOrderTraverse(root->lchild);  
45.         PreOrderTraverse(root->rchild);  
46.     }  
47. }  
48.   
49.   
50. void R_Rotate(BSTree *p)  
51. {  
52.     BSTree lc=(*p)->lchild;  
53.     (*p)->lchild=lc->rchild;  
54.     lc->rchild=*p;  
55.     *p=lc;  
56. }  
57.   
58.   
59. void L_Rotate(BSTree *p)  
60. {  
61.     BSTree rc=(*p)->rchild;  
62.     (*p)->rchild=rc->lchild;  
63.     rc->lchild=*p;  
64.     *p=rc;  
65. }  
66.   
67.   
68. void LeftBalance(BSTree *T)  
69. {  
70.     BSTree lc=(*T)->lchild;  
71.     BSTree rd = lc->rchild;  
72.     switch(lc->bf)  
73.     {  
74.         case LH:  
75.             (*T)->bf=lc->bf=EH;  
76.             R_Rotate(T);  
77.             break;  
78.         case RH:  
79.             switch(rd->bf)  
80.             {  
81.                 case LH:   
82.                     (*T)->bf=RH;  
83.                     lc->bf=EH;  
84.                     break;  
85.                 case EH:  
86.                     (*T)->bf=lc->bf=EH;  
87.                     break;  
88.                 case RH:  
89.                     (*T)->bf=EH;  
90.                     lc->bf=LH;  
91.                     break;  
92.             }  
93.             rd->bf=EH;  
94.             L_Rotate(&((*T)->lchild));  
95.             R_Rotate(T);  
96.             break;  
97.     }  
98. }  
99.   
100.   
101. void RightBalance(BSTree *T)  
102. {  
103.     BSTree rc=(*T)->rchild;  
104.     BSTree ld=rc->lchild;  
105.     switch(rc->bf)  
106.     {  
107.         case RH:  
108.             (*T)->bf=rc->bf=EH;  
109.             L_Rotate(T);  
110.             break;  
111.         case LH:  
112.             switch(ld->bf)  
113.             {  
114.                 case RH:  
115.                     (*T)->bf=LH;  
116.                     rc->bf=EH;  
117.                     break;  
118.                 case EH:  
119.                     (*T)->bf=rc->bf=EH;  
120.                     break;  
121.                 case LH:  
122.                     (*T)->bf=EH;  
123.                     rc->bf=RH;  
124.                     break;  
125.             }  
126.             ld->bf=EH;  
127.             R_Rotate(&((*T)->rchild));  
128.             L_Rotate(T);  
129.             break;  
130.     }  
131. }  
132.   
133.   
134. bool_t InsertAVL(BSTree *t,ElemType e,bool_t *taller)  
135. {  
136.     if(NULL == t)  
137.         return FALSE;  
138.     if(NULL == *t)  
139.     {  
140.         *t=(BSTree)malloc(sizeof(BSTNode));  
141.         if(NULL == *t)  
142.             return FALSE;  
143.         (*t)->key=e;  
144.         (*t)->lchild=(*t)->rchild=NULL;  
145.         (*t)->bf=EH;  
146.         *taller=TRUE;  
147.     }  
148.     else  
149.     {  
150.         if(e==(*t)->key)  
151.         {  
152.             *taller=FALSE;  
153.             return FALSE;  
154.         }  
155.         if(e<(*t)->key)  
156.         {  
157.             if(FALSE == InsertAVL(&((*t)->lchild),e,taller))  
158.                 return FALSE;   
159.             if(*taller)  
160.             {  
161.                 switch((*t)->bf)  
162.                 {  
163.                     case LH:  
164.                         LeftBalance(t);  
165.                         *taller=FALSE;  
166.                         break;  
167.                     case EH:  
168.                         (*t)->bf=LH;  
169.                         *taller=TRUE;  
170.                         break;  
171.                     case RH:  
172.                         (*t)->bf=EH;  
173.                         *taller=FALSE;  
174.                         break;  
175.                 }  
176.             }  
177.         }  
178.         else  
179.         {  
180.             if(FALSE == InsertAVL(&((*t)->rchild),e,taller))  
181.                 return FALSE;   
182.             if(*taller)  
183.             {  
184.                 switch((*t)->bf)  
185.                 {  
186.                     case RH:  
187.                         RightBalance(t);  
188.                         *taller=FALSE;  
189.                         break;  
190.                     case EH:  
191.                         (*t)->bf=RH;  
192.                         *taller=TRUE;  
193.                         break;  
194.                     case LH:  
195.                         (*t)->bf=EH;  
196.                         *taller=FALSE;  
197.                         break;  
198.                 }  
199.             }  
200.         }  
201.     }  
202.     return TRUE;  
203. }  
204.   
205.   
206. BSTree searchAVL(BSTree t,ElemType key)  
207. {  
208.     BSTree p=t;  
209.     while(p)  
210.     {  
211.         if(p->key==key)  
212.             return p;  
213.         else if(p->key<key)  
214.             p=p->rchild;  
215.         else  
216.             p=p->lchild;  
217.     }  
218.     return p;  
219. }  
220.   
221. static void destroy(BSTree *t)  
222. {  
223.     if(NULL != *t)  
224.     {  
225.         destroy(&((*t)->lchild));  
226.         destroy(&((*t)->rchild));  
227.         free(*t);  
228.         *t = NULL;  
229.     }  
230.     return;  
231. }  
232. void destroyAVL(BSTree root)  
233. {  
234.     if(NULL != root)  
235.     {  
236.         destroy(&root);  
237.     }  
238.     return;  
239. }  
240.   
241. int main(int argc,char *argv[])  
242. {  
243.     BSTree root=NULL,r;  
244.     bool_t taller=FALSE;  
245.     int array[]={13,24,37,90,53};  
246.     int i = 0;  
247.     for(i=0;i<5;i++)  
248.         InsertAVL(&root,array[i],&taller);  
249.     printf("inorder traverse\n");  
250.     InOrderTraverse(root);  
251.   
252.     printf("\npreorder traverse\n");  
253.     PreOrderTraverse(root);  
254.   
255.     printf("\nsearch key\n");  
256.     r=searchAVL(root,37);  
257.     if(r)  
258.     {  
259.         printf("%d\n",r->key);  
260.     }  
261.     else  
262.     {  
263.         printf("not find!\n");  
264.     }  
265.     destroyAVL(root);  
266.     root = NULL;  
267. }