写在前面的话:
linux 内核中数据结构的存储已经不在用avl树,我在对应的代码中也没有找到实现,应该是内核中全部用rbtree替换了.zebos中avl树的实现相对较复杂,考虑了临时缓冲等多种因素,不适合作为初学者理解avl树的入门代码,因此,在网络上找到两篇姐姐avl树的文章,讲的很透彻了,以此作入门.理解其它avl树的代码应该很容易了.
正文理解:
AVL树的介绍
AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。
它是最先发明的自平衡二叉查找树，也被称为高度平衡树。相比于"二叉查找树"，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。
上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。
AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。
如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状态就被破坏，它就不再是一棵二叉树；为了让它重新维持在一个平衡状态，就需要对其进行旋转处理。学AVL树，重点的地方也就是它的旋转算法；在后文的介绍中，再来对它进行详细介绍。
AVL树的C实现
1. 节点
1.1 定义
1 typedef int Type;
2
3 typedef struct AVLTreeNode{
4 Type key; // 关键字(键值)
5 int height;
6 struct AVLTreeNode *left; // 左孩子
7 struct AVLTreeNode *right; // 右孩子
8 }Node, *AVLTree;
AVL树的节点包括的几个组成对象:
(01) key -- 是关键字，是用来对AVL树的节点进行排序的。
(02) left -- 是左孩子。
(03) right -- 是右孩子。
(04) height -- 是高度。
1.2 节点的创建
1 /*
2 * 创建AVL树结点。
3 *
4 * 参数说明：
5 * key 是键值。
6 * left 是左孩子。
7 * right 是右孩子。
8 */
9 static Node* avltree_create_node(Type key, Node *left, Node* right)
10 {
11 Node* p;
12
13 if ((p = (Node *)malloc(sizeof(Node))) == NULL)
14 return NULL;
15 p->key = key;
16 p->height = 0;
17 p->left = left;
18 p->right = right;
19
20 return p;
21 }
1.3 树的高度
1 #define HEIGHT(p) ( (p==NULL) ? 0 : (((Node *)(p))->height) )
2
3 /*
4 * 获取AVL树的高度
5 */
6 int avltree_height(AVLTree tree)
7 {
8 return HEIGHT(tree);
9 }
关于高度，有的文章中将"空二叉树的高度定义为-1"，而本文采用*上的定义：树的高度为最大层次。即空的二叉树的高度是0，非空树的高度等于它的最大层次(根的层次为1，根的子节点为第2层，依次类推)。
1.4 比较大小
1 #define MAX(a, b) ( (a) > (b) ? (a) : (b)
2. 旋转
AVL树的基本操作一般涉及运作同在不平衡的二叉查找树所运作的同样的算法。但是要进行预先或随后做一次或多次所谓的"AVL旋转"。
以下图表以四列表示四种情况，每行表示在该种情况下要进行的操作。在左左和右右的情况下，只需要进行一次旋转操作；在左右和右左的情况下，需要进行两次旋转操作。
通过上图可以知道，如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。需要说明的是，下面的内容只给出在这四中情况下如何进行旋转使得avl树达到新的平衡，以帮助读者理解avl树的代码，内容不会涉及具体这样的原因，你只需要知道，看，我进行这样操作后，会重新得到一个二叉平衡搜索树。下面给出它们的示意图：
上图中的4棵树都是"失去平衡的AVL树"，从左往右的情况依次是：LL、LR、RL、RR。总的来说，AVL树失去平衡时的情况一定是LL、LR、RL、RR这4种之一，它们都由各自的定义：
(1) LL：LeftLeft，也称为"左左"。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致"根的左子树的高度"比"根的右子树的高度"大2，导致AVL树失去了平衡。
例如，在上面LL情况中，由于"根节点(8)的左子树(4)的左子树(2)还有非空子节点"，而"根节点(8)的右子树(12)没有子节点"；导致"根节点(8)的左子树(4)高度"比"根节点(8)的右子树(12)"高2。
(2) LR：LeftRight，也称为"左右"。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致"根的左子树的高度"比"根的右子树的高度"大2，导致AVL树失去了平衡。
例如，在上面LR情况中，由于"根节点(8)的左子树(4)的左子树(6)还有非空子节点"，而"根节点(8)的右子树(12)没有子节点"；导致"根节点(8)的左子树(4)高度"比"根节点(8)的右子树(12)"高2。
(3) RL：RightLeft，称为"右左"。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致"根的右子树的高度"比"根的左子树的高度"大2，导致AVL树失去了平衡。
例如，在上面RL情况中，由于"根节点(8)的右子树(12)的左子树(10)还有非空子节点"，而"根节点(8)的左子树(4)没有子节点"；导致"根节点(8)的右子树(12)高度"比"根节点(8)的左子树(4)"高2。
(4) RR：RightRight，称为"右右"。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致"根的右子树的高度"比"根的左子树的高度"大2，导致AVL树失去了平衡。
例如，在上面RR情况中，由于"根节点(8)的右子树(12)的右子树(14)还有非空子节点"，而"根节点(8)的左子树(4)没有子节点"；导致"根节点(8)的右子树(12)高度"比"根节点(8)的左子树(4)"高2。
前面说过，如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。AVL失去平衡之后，可以通过旋转使其恢复平衡，下面分别介绍"LL(左左)，LR(左右)，RR(右右)和RL(右左)"这4种情况对应的旋转方法。
avl树的旋转，核心思想在旋转这一节的第一张图中表达的已经很清楚了，无论是左旋还是右旋（实质上只有两种旋转），在写函数代码的时候，函数的形参是失去平很的根节点root，函数的具体实现内容是，失去平衡的根节点root围绕着平衡后的根节点 pivot进行相应的旋转操作。
LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。如下图：
图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。
LL的旋转代码
1 /*
2 * LL：左左对应的情况(右单旋转)。
3 *
4 * 返回值：旋转后的根节点
5 */
6 static Node* left_left_rotation(AVLTree k2)
7 {
8 AVLTree k1;
9
10 k1 = k2->left;
11 k2->left = k1->right;
12 k1->right = k2;
13
14 k2->height = MAX( HEIGHT(k2->left), HEIGHT(k2->right)) + 1;
15 k1->height = MAX( HEIGHT(k1->left), k2->height) + 1;
16
17 return k1;
18 }
我感觉上面函数名字起得有问题，应该叫做left_left_situation或者right_rotation,因为实际上，对于LL的情形来说，实际上对应的是右旋转:即传入的形参是失去平衡的根节点，函数的内容是失去平衡的根节点root围绕着重新平衡后的根节点pivot进行右旋转操作。
2.2 RR的旋转
理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！RR恢复平衡的旋转方法如下：
图中左边是旋转之前的树，右边是旋转之后的树。RR旋转也只需要一次即可完成。
RR的旋转代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/*
* RR：右右对应的情况(左单旋转)。
*
* 返回值：旋转后的根节点
*/
static
Node* right_right_rotation(AVLTree k1)
{
AVLTree k2;
k2 = k1->right;
k1->right = k2->left;
k2->left = k1;
k1->height = MAX( HEIGHT(k1->left), HEIGHT(k1->right)) + 1;
k2->height = MAX( HEIGHT(k2->right), k1->height) + 1;
return
k2;
}
|
我感觉上面函数名字起得有问题，应该叫做right_right_situation或者left_rotation,因为实际上，对于RR的情形来说，实际上对应的是左旋转:即传入的形参是失去平衡的根节点，函数的内容是失去平衡的根节点root围绕着重新平衡后的根节点pivot进行左旋转操作。
2.3 LR的旋转
LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。如下图
第一次旋转是围绕"k1"进行的"RR旋转"，第二次是围绕"k3"进行的"LL旋转"。
LR的旋转代码
1 /*
2 * LR：左右对应的情况(左双旋转)。
3 *
4 * 返回值：旋转后的根节点
5 */
6 static Node* left_right_rotation(AVLTree k3)
7 {
8 k3->left = right_right_rotation(k3->left);
9
10 return left_left_rotation(k3);
11 }
12 复制代码
左右旋转的情况结合本节第一张图最好理解。
2.4 RL的旋转
RL是与LR的对称情况！RL恢复平衡的旋转方法如下：
RL的情况结合本节第一张图最好理解。
1 /*
2 * RL：右左对应的情况(右双旋转)。
3 *
4 * 返回值：旋转后的根节点
5 */
6 static Node* right_left_rotation(AVLTree k1)
7 {
8 k1->right = left_left_rotation(k1->right);
9
10 return right_right_rotation(k1);
11 }
3. 插入
插入节点的代码
1 /*
2 * 将结点插入到AVL树中，并返回根节点
3 *
4 * 参数说明：
5 * tree AVL树的根结点
6 * key 插入的结点的键值
7 * 返回值：
8 * 根节点
9 */
10 Node* avltree_insert(AVLTree tree, Type key)
11 {
12 if (tree == NULL)
13 {
14 // 新建节点
15 tree = avltree_create_node(key, NULL, NULL);
16 if (tree==NULL)
17 {
18 printf("ERROR: create avltree node failed!\n");
19 return NULL;
20 }
21 }
22 else if (key < tree->key) // 应该将key插入到"tree的左子树"的情况
23 {
24 tree->left = avltree_insert(tree->left, key);
25 // 插入节点后，若AVL树失去平衡，则进行相应的调节。
26 if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
27 {
28 if (key < tree->left->key)
29 tree = left_left_rotation(tree);
30 else
31 tree = left_right_rotation(tree);
32 }
33 }
34 else if (key > tree->key) // 应该将key插入到"tree的右子树"的情况
35 {
36 tree->right = avltree_insert(tree->right, key);
37 // 插入节点后，若AVL树失去平衡，则进行相应的调节。
38 if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
39 {
40 if (key > tree->right->key)
41 tree = right_right_rotation(tree);
42 else
43 tree = right_left_rotation(tree);
44 }
45 }
46 else //key == tree->key)
47 {
48 printf("添加失败：不允许添加相同的节点！\n");
49 }
50
51 tree->height = MAX( HEIGHT(tree->left), HEIGHT(tree->right)) + 1;
52
53 return tree;
54 }
4. 删除
删除节点的代码
1 /*
2 * 删除结点(z)，返回根节点
3 *
4 * 参数说明：
5 * ptree AVL树的根结点
6 * z 待删除的结点
7 * 返回值：
8 * 根节点
9 */
10 static Node* delete_node(AVLTree tree, Node *z)
11 {
12 // 根为空 或者 没有要删除的节点，直接返回NULL。
13 if (tree==NULL || z==NULL)
14 return NULL;
15
16 if (z->key < tree->key) // 待删除的节点在"tree的左子树"中
17 {
18 tree->left = delete_node(tree->left, z);
19 // 删除节点后，若AVL树失去平衡，则进行相应的调节。
20 if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
21 {
22 Node *r = tree->right;
23 if (HEIGHT(r->left) > HEIGHT(r->right))
24 tree = right_left_rotation(tree);
25 else
26 tree = right_right_rotation(tree);
27 }
28 }
29 else if (z->key > tree->key)// 待删除的节点在"tree的右子树"中
30 {
31 tree->right = delete_node(tree->right, z);
32 // 删除节点后，若AVL树失去平衡，则进行相应的调节。
33 if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
34 {
35 Node *l = tree->left;
36 if (HEIGHT(l->right) > HEIGHT(l->left))
37 tree = left_right_rotation(tree);
38 else
39 tree = left_left_rotation(tree);
40 }
41 }
42 else // tree是对应要删除的节点。
43 {
44 // tree的左右孩子都非空
45 if ((tree->left) && (tree->right))
46 {
47 if (HEIGHT(tree->left) > HEIGHT(tree->right))
48 {
49 // 如果tree的左子树比右子树高；
50 // 则(01)找出tree的左子树中的最大节点
51 // (02)将该最大节点的值赋值给tree。
52 // (03)删除该最大节点。
53 // 这类似于用"tree的左子树中最大节点"做"tree"的替身；
54 // 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的。
55 Node *max = avltree_maximum(tree->left);
56 tree->key = max->key;
57 tree->left = delete_node(tree->left, max);
58 }
59 else
60 {
61 // 如果tree的左子树不比右子树高(即它们相等，或右子树比左子树高1)
62 // 则(01)找出tree的右子树中的最小节点
63 // (02)将该最小节点的值赋值给tree。
64 // (03)删除该最小节点。
65 // 这类似于用"tree的右子树中最小节点"做"tree"的替身；
66 // 采用这种方式的好处是：删除"tree的右子树中最小节点"之后，AVL树仍然是平衡的。
67 Node *min = avltree_maximum(tree->right);
68 tree->key = min->key;
69 tree->right = delete_node(tree->right, min);
70 }
71 }
72 else
73 {
74 Node *tmp = tree;
75 tree = tree->left ? tree->left : tree->right;
76 free(tmp);
77 }
78 }
79
80 return tree;
81 }
82
83 /*
84 * 删除结点(key是节点值)，返回根节点
85 *
86 * 参数说明：
87 * tree AVL树的根结点
88 * key 待删除的结点的键值
89 * 返回值：
90 * 根节点
91 */
92 Node* avltree_delete(AVLTree tree, Type key)
93 {
94 Node *z;
95
96 if ((z = avltree_search(tree, key)) != NULL)
97 tree = delete_node(tree, z);
98 return tree;
99 }
好了，avl树重点到此结束，后面的内容参考原文吧。
原文链接：http://blog.csdn.net/programmingring/article/details/37969745
以上转自：https://www.cnblogs.com/3me-linux/p/6473836.html
// 代码实现
#include <bits/stdc++.h>
using namespace std;
typedef int Type;
typedef struct AVLTreeNode {
Type key;
int height;
struct AVLTreeNode *left;
struct AVLTreeNode *right;
} Node, *AVLTree;
static Node* avltree_create_node(Type key, Node *left, Node *right) {
Node *p;
if((p = (Node *)malloc(sizeof(Node))) == NULL) {
return NULL;
}
p->key = key;
p->height = 0;
p->left = left;
p->right = right;
return p;
}
#define HEIGHT(p) ((p == NULL) ? 0 : ((Node *)p)->height)
#define MAX(a, b) ((a > b) ? (a) : (b))
//左左情况，右旋
static Node* avltree_right_rotation(AVLTree root) {
AVLTree pivot;
pivot = root->left;
root->left = pivot->right;
pivot->right = root;
root->height = MAX(HEIGHT(root->left), HEIGHT(root->right)) + 1;
pivot->height = MAX(HEIGHT(pivot->left), root->height) + 1;
return pivot;
}
//右右情况，左旋
static Node* avltree_left_rotation(AVLTree root) {
AVLTree pivot;
pivot = root->right;
root->right = pivot->left;
pivot->left = root;
root->height = MAX(HEIGHT(root->left), HEIGHT(root->right)) + 1;
pivot->height = MAX(HEIGHT(pivot->right), root->height) + 1;
return pivot;
}
//左右情况，先左旋后右旋
static Node* avltree_left_right_rotation(AVLTree root) {
root->left = avltree_left_rotation(root->left);
return avltree_right_rotation(root);
}
//右左情况，先右旋后左旋
static Node* avltree_right_left_rotation(AVLTree root) {
root->right = avltree_right_rotation(root->right);
return avltree_left_rotation(root);
}
//Insert
static Node* avltree_insert(AVLTree tree, Type key) {
if(tree == NULL) {
tree = avltree_create_node(key, NULL, NULL);
if(tree == NULL) {
printf("Error: create avltree node failed!\n");
return NULL;
}
}
else if(key < tree->key) {
tree->left = avltree_insert(tree->left, key);
if(HEIGHT(tree->left) - HEIGHT(tree->right) == 2) {
if(key < tree->left->key) {
tree = avltree_right_rotation(tree);
}
else {
tree = avltree_left_right_rotation(tree);
}
}
}
else if(key > tree->key) {
tree->right = avltree_insert(tree->right, key);
if(HEIGHT(tree->right) - HEIGHT(tree->left) == 2) {
if(key > tree->right->key) {
tree = avltree_left_rotation(tree);
}
else {
tree = avltree_right_left_rotation(tree);
}
}
}
else {
printf("Don't allow insert existed node!");
}
tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right)) + 1;
return tree;
}
// MaxKey_Node
static Node* avltree_maximum(AVLTree tree) {
Node *tmp, *maxx = tree;
if(tree->left) {
tmp = avltree_maximum(tree->left);
if(tmp->key > maxx->key) {
maxx = tmp;
}
}
if(tree->right) {
tmp = avltree_maximum(tree->right);
if(tmp->key > maxx->key) {
maxx = tmp;
}
}
return maxx;
}
//MinKey_Node
static Node* avltree_minimum(AVLTree tree) {
Node *tmp, *minn = tree;
if(tree->left) {
tmp = avltree_minimum(tree->left);
if(tmp->key < minn->key) {
minn = tmp;
}
}
if(tree->right) {
tmp = avltree_minimum(tree->right);
if(tmp->key < minn->key) {
minn = tmp;
}
}
return minn;
}
//Delete
static Node* avltree_delete(AVLTree tree, Node *x) {
if(tree == NULL || x == NULL) {
return NULL;
}
if(x->key < tree->key) {
tree->left = avltree_delete(tree->left, x);
if(HEIGHT(tree->right) - HEIGHT(tree->left) == 2) {
Node *r = tree->right;
if(HEIGHT(r->left) < HEIGHT(r->right)) {
tree = avltree_left_rotation(tree);
}
else {
tree = avltree_right_left_rotation(tree);
}
}
}
else if(x->key > tree->key) {
tree->right = avltree_delete(tree->right, x);
if(HEIGHT(tree->left) - HEIGHT(tree->right) == 2) {
Node *l = tree->left;
if(HEIGHT(l->left) > HEIGHT(l->right)) {
tree = avltree_right_rotation(tree);
}
else {
tree = avltree_left_right_rotation(tree);
}
}
}
else {
if((tree->left) && (tree->right)) {
if(HEIGHT(tree->left) > HEIGHT(tree->right)) {
Node *maxx = avltree_maximum(tree->left);
tree->key = maxx->key;
tree->left = avltree_delete(tree->left, maxx);
}
else {
Node *minn = avltree_minimum(tree->right);
tree->key = minn->key;
tree->right = avltree_delete(tree->right, minn);
}
}
else {
Node *tmp = tree;
tree = tree->left ? tree->left : tree->right;
free(tmp);
}
}
if(tree) {
tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right)) + 1;
}
return tree;
}
//Visit
static void avltree_visit(AVLTree tree) {
queue<AVLTree> q;
if(tree == NULL) {
return;
}
q.push(tree);
while(!q.empty()) {
Node *tmp = q.front();
q.pop();
printf("%d ", tmp->key);
if(tmp->left) {
q.push(tmp->left);
}
if(tmp->right) {
q.push(tmp->right);
}
}
printf("\n");
}
int main() {
int a[] = {1, 4, 3, 5, 2, 6, 7};
AVLTree root = NULL;
// 模拟insert
for(int i = 0; i < 7; ++i) {
root = avltree_insert(root, a[i]);
}
avltree_visit(root);
AVLTree tmp = avltree_create_node(2, NULL, NULL);
// 模拟delete
root = avltree_delete(root, tmp);
avltree_visit(root);
return 0;
}
/*
*
* O O O
* / \ del 2 / \ rotation / \
* O O ===> O O ===> O O
* \ / \ / \ / \ \
* O O O O O O O O
* \ \
* O O
*/
继续加油~