树之完全二叉树(AVL树)
目录
- AVL树的简介
- AVL举例以及详细分析
- 代码块
- 测试结果和参考图纸
- 备注
AVL树的简介
AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。
它是最先发明的自平衡二叉查找树，也被称为高度平衡树。相比于”二叉查找树”，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。
这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。
上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。
AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。
如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状态就被破坏，它就不再是一棵二叉树；为了让它重新维持在一个平衡状态，就需要对其进行旋转处理。学AVL树，重点的地方也就是它的旋转算法；在后文的介绍中，再来对它进行详细介绍。
AVL举例以及详细分析
AVL树的自平衡操作——旋转：
前面说过，如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。下面给出它们的示意图：
上面的两张图都是为了便于理解，而列举的关于”失去平衡的AVL树”的例子。总的来说，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。**
LL的旋转：
图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。
对于LL旋转，你可以这样理解为：LL旋转是围绕”失去平衡的AVL根节点”进行的，也就是节点k2；而且由于是LL情况，即左左情况，就用手抓着”左孩子，即k1”使劲摇。将k1变成根节点，k2变成k1的右子树，”k1的右子树”变成”k2的左子树”。
RR的旋转 ：
理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！
LR的旋转 ：
LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。第一次旋转是围绕”k1”进行的”RR旋转”，第二次是围绕”k3”进行的”LL旋转”。
RL的旋转 ：
RL是与LR的对称情况！第一次旋转是围绕”k3”进行的”LL旋转”，第二次是围绕”k1”进行的”RR旋转”。
代码块
#include<stdio.h>
#include<stdlib.h>
#define HEIGHT(p) ((p==NULL)?-1:(((Node *)(p))->height))
#define MAX(a,b) ((a)>(b)?(a):(b))
typedef int Type;
typedef struct AVLTreeNode
{
Type key;//关键字（键值）
int height;
struct AVLTreeNode *left;
struct AVLTreeNode *right;
}Node, *AVLTree;
int avltree_height(AVLTree tree);
void preorder_avltree(AVLTree tree);
void inorder_avltree(AVLTree tree);
void postorder_avltree(AVLTree tree);
AVLTree avltree_search(AVLTree x,Type key);
AVLTree avltree_minimum(AVLTree tree);
AVLTree avltree_maximum(AVLTree tree);
AVLTree avltree_insert(AVLTree tree, Type key);
AVLTree avltree_delete(AVLTree tree, Type key);
void destory_avltree(AVLTree tree);
int avltree_height(AVLTree tree)
{
return HEIGHT(tree);
}
void preorder_avltree(AVLTree tree)
{
if (tree != NULL)
{
printf("%d ", tree->key);
preorder_avltree(tree->left);
preorder_avltree(tree->right);
}
}
void inorder_avltree(AVLTree tree)
{
if (tree != NULL)
{
inorder_avltree(tree->left);
printf("%d ", tree->key);
inorder_avltree(tree->right);
}
}
void postorder_avltree(AVLTree tree)
{
if (tree != NULL)
{
postorder_avltree(tree->left);
postorder_avltree(tree->right);
printf("%d ", tree->key);
}
}
AVLTree avltree_search(AVLTree x, Type key)
{
if (x == NULL || x->key == key)
return x;
if (key < x->key)
return avltree_search(x->left, key);
else
return avltree_search(x->right, key);
}
AVLTree avltree_minimum(AVLTree tree)
{
if (tree == NULL)
{
return NULL;
}
while (tree->left != NULL)
{
tree = tree->left;
}
return tree;
}
AVLTree avltree_maximum(AVLTree tree)
{
if (tree == NULL)
{
return NULL;
}
while (tree->right != NULL)
{
tree = tree->right;
}
return tree;
}
AVLTree left_left_rotation(AVLTree k2)//LL左左对应情况（左单旋转）
{
AVLTree k1;
k1 = k2->left;
k2->left = k1->right;
k1->right = k2;
k2->height = MAX(HEIGHT(k2->left), HEIGHT(k2->right)) + 1;
k1->height = MAX(HEIGHT(k1->left), k2->height) + 1;
return k1;//返回值为旋转后的根节点
}
AVLTree right_right_rotation(AVLTree k1)//RR右右对应情况（右单旋转）
{
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;//返回值为旋转后的根节点
}
AVLTree left_right_rotation(AVLTree k3)//LR
{
k3->left = right_right_rotation(k3->left);
return left_left_rotation(k3);//返回值为旋转后的根节点
}
AVLTree right_left_rotation(AVLTree k1)//RL
{
k1->right = left_left_rotation(k1->right);
return right_right_rotation(k1);//返回值为旋转后的根节点
}
AVLTree avltree_insert(AVLTree tree, Type key)
{
//key是要插入的键值
if (tree == NULL)
{
tree = (Node *)malloc(sizeof(Node));
if (tree == NULL)
{
printf("ERROR:creat avltree node failed!\n");
}
tree->key = key;
tree->height = 0;
tree->left = NULL;
tree->right = NULL;
}
else if (key < tree->key)//key应该插入tree的左子树中
{
tree->left = avltree_insert(tree->left, key);
//插入节点后若avl树失去平衡，则应该进行相应的调节
if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
{
if (key < tree->left->key)
{
tree = left_left_rotation(tree);
}
else
{
tree = left_right_rotation(tree);
}
}
}
else if (key > tree->key)//key应该插入tree的右子树中
{
tree->right = avltree_insert(tree->right, key);
//插入节点后若avl树失去平衡，则应该进行相应的调节
if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
{
if (key>tree->right->key)
{
tree = right_right_rotation(tree);
}
else
{
tree = right_left_rotation(tree);
}
}
}
else//key==tree->key
{
printf("添加失败，不允许添加相同的节点!\n");
}
tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right)) + 1;
return tree;
}
AVLTree delete_node(AVLTree tree, AVLTree z)
{
if (tree == NULL || z == NULL)
{
return NULL;
}
if (z->key < tree->key)// 待删除的节点在"tree的左子树"中
{
tree->left = delete_node(tree->left, z);
//删除左子树的节点后后左子树如果比右子树高度小2，进行调整
if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
{
AVLTree r = tree->right;//对右子树进行调整
//如果右子树的左子树比其右子树高度大为RL否则为RR
if (HEIGHT(r->left) > HEIGHT(r->right))
{
tree = right_left_rotation(tree);
}
else
{
tree = right_right_rotation(tree);
}
}
}
else if (z->key>tree->key)// 待删除的节点在"tree的右子树"中
{
tree->right = delete_node(tree->right, z);
//删除右子树的节点后，左子树高度比右子树大2时，进行调整
if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
{
AVLTree l = tree->left;//对左子树进行调整
//如果左子树的右子树比其左子树高度大，为LR,否则为LL
if (HEIGHT(l->right) > HEIGHT(l->left))
{
tree = left_right_rotation(tree);
}
else
{
tree = left_left_rotation(tree);
}
}
}
else//tree对应的是要删除的点
{
if ((tree->left) && (tree->right))// tree的左右孩子都非空
{
if (HEIGHT(tree->left) > HEIGHT(tree->right))
{
// 如果tree的左子树比右子树高；
// 则(01)找出tree的左子树中的最大节点
// (02)将该最大节点的值赋值给tree。
// (03)删除该最大节点。
// 这类似于用"tree的左子树中最大节点"做"tree"的替身；
// 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的。
AVLTree max = avltree_maximum(tree->left);
tree->key = max->key;
tree->left = delete_node(tree->left, max);
}
else
{
// 如果tree的左子树不比右子树高(即它们相等，或右子树比左子树高1)
// 则(01)找出tree的右子树中的最小节点
// (02)将该最小节点的值赋值给tree。
// (03)删除该最小节点。
// 这类似于用"tree的右子树中最小节点"做"tree"的替身；
// 采用这种方式的好处是：删除"tree的右子树中最小节点"之后，AVL树仍然是平衡的。
AVLTree min = avltree_minimum(tree->right);
tree->key = min->key;
tree->right = delete_node(tree->right, min);
}
}
else
{
AVLTree tmp = tree;
tree = tree->left ? tree->left:tree->right;
free(tmp);
}
}
return tree;
}
AVLTree avltree_delete(AVLTree tree, Type key)
{
AVLTree z;
//查看要被删除的节点是否在树中，是则删除！
if ((z = avltree_search(tree, key)) != NULL)
{
tree = delete_node(tree, z);
}
return tree;
}
int main(void)
{
int i, n;
AVLTree root = NULL;
Type tmp;
printf("Number of Elements:");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
printf("Element %d：", i + 1);
scanf("%d", &tmp);
root = avltree_insert(root, tmp);
}
printf("\n== 前序遍历: ");
preorder_avltree(root);
printf("\n== 中序遍历: ");
inorder_avltree(root);
printf("\n== 后序遍历: ");
postorder_avltree(root);
printf("\n");
printf("== 高度: %d\n", avltree_height(root));
printf("== 最小值: %d\n", avltree_minimum(root)->key);
printf("== 最大值: %d\n", avltree_maximum(root)->key);
printf(" \nNode that will be deteleted:");
int m;
scanf("%d", &m);
printf("\n== 删除根节点: %d", m);
root = avltree_delete(root, m);
printf("\n== 高度: %d", avltree_height(root));
printf("\n== 中序遍历: ");
inorder_avltree(root);
system("pause");
return 0;
}测试结果与参考图纸
备注
下面，我们对测试程序的流程进行分析！
1. 新建AVL树
新建AVL树的根节点root。
- 依次添加”3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9” 到AVL树中，过程如下。
输出下面树的信息：
