平衡二叉树 1

平衡二叉树又称AVL树。它或者是颗空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。若将二叉树节点的平衡因子BF定义为该节点的左子树的深度减去它的右子树的深度，则平衡二叉树上所有节点的平衡因子只可能为-1,0,1.只要二叉树上有一个节点的平衡因子的绝对值大于1，那么这颗平衡二叉树就失去了平衡。

假设我们已经有棵平衡二叉树，现在让我们来看看插入节点后，原来节点失去平衡后，我们进行选择的处理方式。

平衡二叉树多用于查找数据，所以平衡二叉树又是颗二叉排序树。

那么如何创建一颗平衡二叉树呢？

创建平衡二叉树，我们采用依次插入节点的方式进行。而平衡二叉树上插入节点采用递归的方式进行。递归算法如下：

（1）      若该树为一空树，那么插入一个数据元素为e的新节点作为平衡二叉树的根节点，树的高度增加1。

（2）      若待插入的数据元素e和平衡二叉树（BBST）的根节点的关键字相等，那么就不需要进行插入操作。

（3）      若待插入的元素e比平衡二叉树（BBST）的根节点的关键字小，而且在BBST的左子树中也不存在和e有相同关键字的节点，则将e插入在BBST的左子树上，并且当插入之后的左子树深度增加1时，分别就下列情况处理之。

(a)    BBST的根节点的平衡因子为-1（右子树的深度大于左子树的深度）：则将根节点的平衡因子更改为0，BBST的深度不变；

(b)    BBST的根节点的平衡因子为0（左右子树的深度相等）：则将根节点的平衡因子修改为1，BBST的深度增加1；

(c)    BBST的根节点的平衡因子为1（左子树的深度大于右子树的深度）：若BBST的左子树根节点的平衡因子为1，则需要进行单向右旋转平衡处理，并且在右旋处理后，将根节点和其右子树根节点的平衡因子更改为0，树的深度不变；

若BBST的左子树根节点的平衡因子为-1，则需进行先向左，后向右的双向旋转平衡处理，并且在旋转处理之后，修改根节点和其左，右子树根节点的平衡因子，树的深度不变；

（4）      若e的关键字大于BBST的根节点的关键字，而且在BBST的右子树中不存在和e有相同关键字的节点，则将e插入到BBST的右子树上，并且当插入之后的右子树深度加1时，分别就不同的情况处理之。

（a）      BBST的根节点的平衡因子是1（左子树的深度大于右子树的深度）：则将根节点的平衡因子修改为0，BBST的深度不变；

（b）      BBST的根节点的平衡因子是0（左右子树的深度相等）：则将根节点的平衡因子修改为-1，树的深度加1；

（c）      BBST的根节点的平衡因子为-1（右子树的深度大于左子树的深度）：若BBST的右子树根节点的平衡因子为1，则需要进行两次选择，第一次先向右旋转，再向左旋转处理，并且在旋转处理之后，修改根节点和其左，右子树根节点的平衡因子，树的深度不变；

若BBST的右子树根节点的平衡因子为1，则需要进行一次向左的旋转处理，并且在左旋之后，更新根节点和其左，右子树根节点的平衡因子，树的深度不变；

下面附上本人的代码：

[cpp] view plain copy print ?

1. #include <stdio.h>   
2. #include <stdlib.h>   
3. /************************************************************************/  
4. /*                    平衡二叉树---AVL                                  */  
5. /************************************************************************/  
6. #define LH +1   
7. #define EH  0   
8. #define RH -1   
9. typedef int ElemType;  
10. typedef struct BSTNode{  
11.     ElemType data;  
12.     int bf;//balance flag   
13.     struct BSTNode *lchild,*rchild;  
14. }*PBSTree;  
15.   
16. void R_Rotate(PBSTree* p)  
17. {  
18.     PBSTree lc = (*p)->lchild;  
19.     (*p)->lchild = lc->rchild;  
20.     lc->rchild = *p;  
21.     *p = lc;  
22. }  
23.   
24. void L_Rotate(PBSTree* p)  
25. {  
26.     PBSTree rc = (*p)->rchild;  
27.     (*p)->rchild = rc->lchild;  
28.     rc->lchild = *p;  
29.     *p = rc;  
30. }  
31.   
32. void LeftBalance(PBSTree* T)  
33. {  
34.     PBSTree lc,rd;  
35.     lc = (*T)->lchild;  
36.     switch (lc->bf)  
37.     {  
38.     case LH:  
39.         (*T)->bf = lc->bf = EH;  
40.         R_Rotate(T);  
41.         break;  
42.     case RH:  
43.         rd = lc->rchild;  
44.         switch(rd->bf)  
45.         {  
46.         case LH:  
47.             (*T)->bf = RH;  
48.             lc->bf = EH;  
49.             break;  
50.         case EH:  
51.             (*T)->bf = lc->bf = EH;  
52.             break;  
53.         case RH:  
54.             (*T)->bf = EH;  
55.             lc->bf = LH;  
56.             break;  
57.         }  
58.         rd->bf = EH;  
59.         L_Rotate(&(*T)->lchild);  
60.         R_Rotate(T);  
61.         break;  
62.     }  
63. }  
64.   
65. void RightBalance(PBSTree* T)  
66. {  
67.     PBSTree lc,rd;  
68.     lc= (*T)->rchild;  
69.     switch (lc->bf)  
70.     {  
71.     case RH:  
72.         (*T)->bf = lc->bf = EH;  
73.         L_Rotate(T);  
74.         break;  
75.     case LH:  
76.         rd = lc->lchild;  
77.         switch(rd->bf)  
78.         {  
79.         case LH:  
80.             (*T)->bf = EH;  
81.             lc->bf = RH;  
82.             break;  
83.         case EH:  
84.             (*T)->bf = lc->bf = EH;  
85.             break;  
86.         case RH:  
87.             (*T)->bf = EH;  
88.             lc->bf = LH;  
89.             break;  
90.         }  
91.         rd->bf = EH;  
92.         R_Rotate(&(*T)->rchild);  
93.         L_Rotate(T);  
94.         break;  
95.     }  
96. }  
97.   
98. int InsertAVL(PBSTree* T,ElemType e,bool* taller)  
99. {  
100.     if ((*T)==NULL)  
101.     {  
102.         (*T)=(PBSTree)malloc(sizeof(BSTNode));  
103.         (*T)->bf = EH;  
104.         (*T)->data = e;  
105.         (*T)->lchild = NULL;  
106.         (*T)->rchild = NULL;  
107.     }  
108.     else if (e == (*T)->data)  
109.     {  
110.         *taller = false;  
111.         return 0;  
112.     }  
113.     else if (e < (*T)->data)  
114.     {  
115.         if(!InsertAVL(&(*T)->lchild,e,taller))  
116.             return 0;  
117.         if(*taller)  
118.         {  
119.             switch ((*T)->bf)  
120.             {  
121.             case LH:  
122.                 LeftBalance(T);  
123.                 *taller = false;  
124.                 break;  
125.             case  EH:  
126.                 (*T)->bf = LH;  
127.                 *taller = true;  
128.                 break;  
129.             case RH:  
130.                 (*T)->bf = EH;  
131.                 *taller = false;  
132.                 break;  
133.             }  
134.         }  
135.     }  
136.     else  
137.     {  
138.         if(!InsertAVL(&(*T)->rchild,e,taller))  
139.             return 0;  
140.         if (*taller)  
141.         {  
142.             switch ((*T)->bf)  
143.             {  
144.             case LH:  
145.                 (*T)->bf = EH;  
146.                 *taller = false;  
147.                 break;  
148.             case EH:  
149.                 (*T)->bf = RH;  
150.                 *taller = true;  
151.                 break;  
152.             case  RH:  
153.                 RightBalance(T);  
154.                 *taller = false;  
155.                 break;  
156.             }  
157.         }  
158.     }  
159.     return 1;  
160. }  
161.   
162. bool FindNode(PBSTree root,ElemType e,PBSTree* pos)  
163. {  
164.     PBSTree pt = root;  
165.     (*pos) = NULL;  
166.     while(pt)  
167.     {  
168.         if (pt->data == e)  
169.         {  
170.             //找到节点，pos指向该节点并返回true   
171.             (*pos) = pt;  
172.             return true;  
173.         }  
174.         else if (pt->data>e)  
175.         {  
176.             pt = pt->lchild;  
177.         }  
178.         else  
179.             pt = pt->rchild;  
180.     }  
181.     return false;  
182. }  
183. void InorderTra(PBSTree root)  
184. {  
185.     if(root->lchild)  
186.         InorderTra(root->lchild);  
187.     printf("%d ",root->data);  
188.     if(root->rchild)  
189.         InorderTra(root->rchild);  
190. }  
191.   
192. int main()  
193. {  
194.     int i,nArr[] = {1,23,45,34,98,9,4,35,23};  
195.     PBSTree root=NULL,pos;  
196.     bool taller;  
197.     for (i=0;i<9;i++)  
198.     {  
199.         InsertAVL(&root,nArr[i],&taller);  
200.     }  
201.     InorderTra(root);  
202.     if(FindNode(root,103,&pos))  
203.         printf("\n%d\n",pos->data);  
204.     else  
205.         printf("\nNot find this Node\n");  
206.     return 0;  
207. }