平衡二叉树

 

[置顶] 数据结构： 平衡二叉树

分类： C Program Algorithms Data structs 2012-10-27 22:33  31939人阅读  评论(0)  收藏  举报

目录(?)[+]

一、定义

        平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用算法有红黑树、AVL、Treap、伸展树等。

     平衡二叉树是在二叉排序树(BST)上引入的，就是为了解决二叉排序树的不平衡性导致时间复杂度大大下降，那么AVL就保持住了(BST)的最好时间复杂度O(logn)，所以每次的插入和删除都要确保二叉树的平衡。平衡二叉树见图1所示。

图1（a）平衡二叉树                      （b）非平衡二叉树

二、作用

        对于一般的二叉搜索树（Binary Search Tree），其期望高度（即为一棵平衡树时）为log2n，其各操作的时间复杂度（O(log2n)）同时也由此而决定。但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。我们可以通过随机化建立二叉搜索树来尽量的避免这种情况，但是在进行了多次的操作之后，由于在删除时，我们总是选择将待删除节点的后继代替它本身，这样就会造成总是右边的节点数目减少，以至于树向左偏沉。这同时也会造成树的平衡性受到破坏，降低它的操作的时间复杂度。
    平衡二叉搜索树（Balanced Binary Tree）具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。常用算法有红黑树、AVL、Treap、伸展树等。在平衡二叉搜索树中，我们可以看到，其高度一般都良好地维持在O（log2n），大大降低了操作的时间复杂度。

三、动态平衡技术

1.动态平衡技术

        Adelson-Velskii 和 Landis 提出了一个动态地保持二叉1.动态平衡技术
        Adelson-Velskii 和 Landis 提出了一个动态地保持二叉排序树平衡的方法，其基本思想是：在构造二叉排序树的过程中，每当插入一个结点时，首先检查是否因插入而破坏了树的平衡性，如果是因插入结点而破坏了树的平衡性，则找出其中最小不平衡子树，在保持排序树特性的前提下，调整最小不平衡子树中各结点之间的连接关系，以达到新的平衡。通常将这样得到的平衡二叉排序树简称为 AVL 树。

2.最小不平衡子树

        以离插入结点最近、且平衡因子绝对值大于 1 的结点作根结点的子树。为了简化讨论，不妨假设二叉排序树的最小不平衡子树的根结点为 A ，则调整该子树的规律可归纳为下列四种情况：

（1） LL 型：
　　新结点 X 插在 A 的左孩子的左子树里。调整方法见图 2(a) 。图中以 B 为轴心，将 A 结点从 B 的右上方转到 B 的右下侧，使 A 成为 B 的右孩子。

图2

（2）RR 型：
　　新结点 X 插在 A 的右孩子的右子树里。调整方法见图 2(b) 。图中以 B 为轴心，将 A 结点从 B 的左上方转到 B 的左下侧，使 A 成为 B 的左孩子。
（3）LR 型：
　　新结点 X 插在 A 的左孩子的右子树里。调整方法见图 2(c) 。分为两步进行：第一步以 X 为轴心，将 B 从 X 的左上方转到 X 的左下侧，使 B 成为 X 的左孩子， X 成为 A 的左孩子。第二步跟 LL 型一样处理 ( 应以 X 为轴心 ) 。
（4）RL 型：
　　新结点 X 插在 A 的右孩子的左子树里。调整方法见图 2(d) 。分为两步进行：第一步以 X 为轴心，将 B 从 X 的右上方转到 X 的右下侧，使 B 成为 X 的右孩子， X 成为 A 的右孩子。第二步跟 RR 型一样处理 ( 应以 X 为轴心 ) 。

        实际的插入情况，可能比图2要复杂。因为 A 、 B 结点可能还会有子树。现举一例说明，设一组记录的关键字按以下次序进行插入： 4 、 5 、 7 ， 2 、 1 、 3 、 6 ，其生成及调整成二叉平衡树的过程示于图 3。
　　在图 3 中，当插入关键字为 3 的结点后，由于离结点 3 最近的平衡因子为 2 的祖先是根结点 5 。所以，第一次旋转应以结点 4 为轴心，把结点 2 从结点 4 的左上方转到左下侧，从而结点 5 的左孩子是结点 4 ，结点 4 的左孩子是结点 2 ，原结点 4 的左孩子变成了结点 2 的右孩子。第二步再以结点 4 为轴心，按 LL 类型进行转换。这种插入与调整平衡的方法可以编成算法和程序，这里就不再讨论了。

图3 平衡二叉树的建立

3.代码实现

utl.h

[cpp]  view plain copy print ?

1. #ifndef UTL_H_  
2. #define UTL_H_  
3. /* 
4.  *整理了一些常用的功能，如内存管理 
5.  */  
6. #include <stdio.h>  
7. #include <stdlib.h>  
8.   
9. /*申请内存*/  
10. inline void *xalloc(int size)  
11. {  
12.     void *p;  
13.     p = (void *)malloc(size);  
14.     /*申请失败*/  
15.     if(p == NULL)  
16.     {  
17.         printf("alloc error\n");  
18.         exit(1);  
19.     }  
20.     return p;  
21. }  
22. /*内存释放*/  
23. #define xfree(p) free(p)  
24.   
25. #endif  

avl.h

[cpp]  view plain copy print ?

1. #ifndef AVL_H__  
2. #define AVL_H__  
3. /* 
4.  *avl树数据结构及相关操作 
5.  */  
6. #include <stdio.h>  
7. #include <stdlib.h>  
8.   
9. struct AVLTree  
10. {  
11.     unsigned int nData;    /*存储数据*/  
12.     struct AVLTree* pLeft;    /*指向左子树*/  
13.     struct AVLTree* pRight;    /*指向右子树*/  
14.     int nHeight;    /*树的平衡度*/  
15. };  
16.   
17. /*插入操作*/  
18. struct AVLTree* insert_tree(unsigned int nData, struct AVLTree* pNode);  
19.   
20. /*查找操作，找到返回1，否则，返回0*/  
21. int find_tree(unsigned int data, struct AVLTree* pRoot);  
22.   
23. /*删除操作,删除所有节点*/  
24. void delete_tree(struct AVLTree** ppRoot);  
25.   
26. /*打印操作*/  
27. void print_tree(struct AVLTree* pRoot);  
28.   
29. #endif  

avl.c

[cpp]  view plain copy print ?

1. #include "avl.h"  
2.   
3. #include "utl.h"  
4.   
5. static int Max(int a, int b);  
6. static int Height(struct AVLTree* pNode);  
7.   
8. /*旋转操作*/  
9. static struct AVLTree* SingleRotateWithLeft(struct AVLTree* pNode);  
10. static struct AVLTree* SingleRotateWithRight(struct AVLTree* pNode);  
11. static struct AVLTree* DoubleRotateWithLeft(struct AVLTree* pNode);  
12. static struct AVLTree* DoubleRotateWithRight(struct AVLTree* pNode);  
13.   
14. struct AVLTree* insert_tree(unsigned int nData, struct AVLTree* pNode)  
15. {  
16.     if (NULL == pNode)  
17.     {  
18.         pNode = (struct AVLTree*)xalloc(sizeof(struct AVLTree));  
19.         pNode->nData = nData;  
20.         pNode->nHeight = 0;  
21.         pNode->pLeft = pNode->pRight = NULL;  
22.     }  
23.     else if (nData < pNode->nData)    /*插入到左子树中*/  
24.     {  
25.         pNode->pLeft = insert_tree(nData, pNode->pLeft);  
26.         if (Height(pNode->pLeft) - Height(pNode->pRight) == 2)    /*AVL树不平衡*/  
27.         {  
28.             if (nData < pNode->pLeft->nData)  
29.             {  
30.                 /*插入到了左子树左边, 做单旋转*/  
31.                 pNode = SingleRotateWithLeft(pNode);  
32.             }  
33.             else  
34.             {  
35.                 /*插入到了左子树右边, 做双旋转*/  
36.                 pNode = DoubleRotateWithLeft(pNode);  
37.             }  
38.         }  
39.     }  
40.     else if (nData > pNode->nData)    /*插入到右子树中*/  
41.     {  
42.         pNode->pRight = insert_tree(nData, pNode->pRight);  
43.         if (Height(pNode->pRight) - Height(pNode->pLeft) == 2)    /*AVL树不平衡*/  
44.         {  
45.             if (nData > pNode->pRight->nData)  
46.             {  
47.                 /*插入到了右子树右边, 做单旋转*/  
48.                 pNode = SingleRotateWithRight(pNode);  
49.             }  
50.             else  
51.             {  
52.                 /*插入到了右子树左边, 做双旋转*/  
53.                 pNode = DoubleRotateWithRight(pNode);  
54.             }  
55.         }  
56.     }  
57.   
58.     pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;  
59.   
60.     return pNode;  
61. }  
62.   
63.   
64. /*删除树*/  
65. void delete_tree(struct AVLTree** ppRoot)  
66. {  
67.     if (NULL == ppRoot || NULL == *ppRoot)  
68.         return;  
69.   
70.     delete_tree(&((*ppRoot)->pLeft));  
71.     delete_tree(&((*ppRoot)->pRight));  
72.     xfree(*ppRoot);  
73.     *ppRoot = NULL;  
74. }  
75.   
76. /*中序遍历打印树的所有结点, 因为左结点 < 父结点 < 右结点, 因此打印出来数据的大小是递增的*/  
77. void print_tree(struct AVLTree* pRoot)  
78. {  
79.     if (NULL == pRoot)  
80.         return;  
81.   
82.     static int n = 0;  
83.   
84.   
85.     print_tree(pRoot->pLeft);  
86.     printf("[%d]nData = %u\n", ++n, pRoot->nData);  
87.     print_tree(pRoot->pRight);  
88. }  
89.   
90. /* 
91.  *查找操作，找到返回1，否则，返回0 
92.  *data是待查找的数据 
93.  *pRoot:avl树的指针 
94.  */  
95. int find_tree(unsigned int data, struct AVLTree* pRoot)  
96. {  
97.     static int k=1;    /*查找次数*/  
98.     if (NULL == pRoot)  
99.     {  
100.         printf("not find %d times\n", k);  
101.         return 0;  
102.     }  
103.   
104.     if(data == pRoot->nData)  
105.     {  
106.         printf("find:%d times\n", k);  
107.         return 1;  
108.     }  
109.     else if(data < pRoot->nData)  
110.     {  
111.         ++k;  
112.         return find_tree(data, pRoot->pLeft);  
113.     }  
114.     else if(data > pRoot->nData)  
115.     {  
116.         ++k;  
117.         return find_tree(data, pRoot->pRight);  
118.     }  
119. }  
120.   
121. static int Max(int a, int b)  
122. {  
123.     return (a > b ? a : b);  
124. }  
125.   
126. /*返回节点的平衡度*/  
127. static int Height(struct AVLTree* pNode)  
128. {  
129.     if (NULL == pNode)  
130.         return -1;  
131.   
132.     return pNode->nHeight;  
133. }  
134.   
135. /******************************************************************** 
136.       pNode pNode->pLeft 
137.       / \ 
138.   pNode->pLeft ==> pNode 
139.       \     / 
140.   pNode->pLeft->pRight pNode->pLeft->pRight 
141.  *********************************************************************/  
142. static struct AVLTree* SingleRotateWithLeft(struct AVLTree* pNode)  
143. {  
144.     struct AVLTree* pNode1;  
145.   
146.     pNode1 = pNode->pLeft;  
147.     pNode->pLeft = pNode1->pRight;  
148.     pNode1->pRight = pNode;  
149.   
150.     /*结点的位置变了, 要更新结点的高度值*/  
151.     pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;  
152.     pNode1->nHeight = Max(Height(pNode1->pLeft), pNode->nHeight) + 1;  
153.   
154.     return pNode1;  
155. }  
156.   
157. /******************************************************************** 
158.   pNode pNode->pRight 
159.   \ / 
160.   pNode->pRight ==> pNode 
161.   / \ 
162.   pNode->pRight->pLeft pNode->pRight->pLeft 
163.  *********************************************************************/  
164. static struct AVLTree* SingleRotateWithRight(struct AVLTree* pNode)  
165. {  
166.     struct AVLTree* pNode1;  
167.   
168.     pNode1 = pNode->pRight;  
169.     pNode->pRight = pNode1->pLeft;  
170.     pNode1->pLeft = pNode;  
171.   
172.     /*结点的位置变了, 要更新结点的高度值*/  
173.     pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;  
174.     pNode1->nHeight = Max(Height(pNode1->pRight), pNode->nHeight) + 1;  
175.   
176.     return pNode1;  
177. }  
178.   
179. static struct AVLTree* DoubleRotateWithLeft(struct AVLTree* pNode)  
180. {  
181.     pNode->pLeft = SingleRotateWithRight(pNode->pLeft);  
182.   
183.     return SingleRotateWithLeft(pNode);  
184. }  
185.   
186. static struct AVLTree* DoubleRotateWithRight(struct AVLTree* pNode)  
187. {  
188.     pNode->pRight = SingleRotateWithLeft(pNode->pRight);  
189.   
190.     return SingleRotateWithRight(pNode);  
191. }  

测试函数

[cpp]  view plain copy print ?

1. #include <stdio.h>  
2.   
3. #include <time.h>  
4.   
5. #include "avl.h"  
6.   
7. int main()  
8. {  
9.     int i,j;  
10.     AVLTree* pRoot = NULL;  
11.   
12.     srand((unsigned int)time(NULL));  
13.       
14.     for (i = 0; i < 10; ++i)  
15.     {  
16.             j = rand();  
17.             printf("%d\n", j);  
18.         pRoot = Insert(j, pRoot);  
19.     }  
20.   
21.     PrintTree(pRoot);  
22.   
23.     DeleteTree(&pRoot);  
24.   
25.     return 0;  
26. }  

四、参考文献

1、http://sjjg.js.zwu.edu.cn/SFXX/chazhao/chazhao7.3.2.2.html

2、baike.baidu.com/view/593144.htm

3、http://caoruntao.iteye.com/blog/1013550