AVL树的插入、删除、查找操作

AVL树是一种带有平衡条件的二叉查找树，所有节点都是基于平衡的。所谓平衡，即某个节点的左右子树的高度差最多相差1。空树的高度定义为-1。

下面我们通过如下两棵树（图片来自《数据结构与算法分析–C语言描述》）进一步了解怎样的树才是AVL树。



上图只有左边的树才是AVL树，那么下面我们来分析一下左边的树

（某个节点的高 = MAX（子树的高, 右子树的高 ）+ 1）

节点3的高为0

节点4的高为1

节点1的高为0

节点7的高为0

节点2的高为2

节点8的高为1

节点5的高为3

你可以看到任一节点的左右子树的差都没有超过2，那么我们再看看右边的树

节点2的高为2

节点8的高为0

所以对于节点7来说，左右子树的高度差相差为2 > 1，失去平衡。

下面我们接着来说AVL的插入、删除、查找操作。

插入和删除操作都有可能导致AVL树的不平衡（为什么呢？原来的树是平衡的，即某个节点的左右子树的高度差小于2，假设左子树的高为1，右子树的高为0，如果这个时候，在这个节点的左子树插入一个节点，那么该节点的左右子树的高度差就为2了，删除操作也是一样的）。

对于出现不平衡的时候，需要通过旋转来解决。下面我们直接来看看插入操作。

插入操作

插入节点==》有可能失去平衡==》通过旋转操作来使树达到平衡

我们把需要重新平衡的节点叫做A，那么出现不平衡的情况，会有下面四种：

1. 对A节点的左儿子的左子树进行插入

2. 对A节点的左儿子的右子树进行插入

3. 对A节点的右儿子的左子树进行插入

4. 对A节点的右儿子的右子树进行插入

下图对应上面四种情况



针对情况一和情况四，我们采取的是单旋转（旋转一次）的操作

针对情况二和情况三，我们采取的是双旋转（旋转两次）的操作

单旋转，其法则是，如果哪边偏高，就往另一边旋转，

如情况一，旋转后的效果如下图



情况四旋转后的效果如下图



下图（来自《数据结构与算法分析–C语言描述》）对应情况一，从图中可以看出，K2的左右节点的高度差为2，不平衡，左边偏高，所以要往右边旋转。



我们直接来看看该单旋转算法的实现

Position * avl_tree_single_rotate_with_left(AVL_TREE * k2)
{
Position * k1;

k1 = k2->lChild;
k2->lChild = k1->rChild;
k1->rChild = k2;

k2->height = avl_tree_max(avl_tree_height(k2->lChild), avl_tree_height(k2->rChild)) + 1;
k1->height = avl_tree_max(avl_tree_height(k1->lChild), avl_tree_height(k1->rChild)) + 1;

return k1;
}

双旋转，先旋转失去平衡节点K3的第一个儿子节点K1，然后再旋转K3。如情况二，旋转后的最终效果如下图



情况三，旋转后的最终效果如下图



下图（来自《数据结构与算法分析–C语言描述》）对应情况二，从图上可以看出，K3节点的左右子树高度差为2，不平衡，需要先旋转K1和K2，然后再旋转K2和K3。



我们来看看该双旋转算法的实现

Position * avl_tree_double_rotate_with_left(AVL_TREE * k3)
{
/* Rotate between k1 and k2 */
k3->lChild = avl_tree_single_rotate_with_right(k3->lChild);

/* Rotate between k2 and k3 */
return avl_tree_single_rotate_with_left(k3);
}

删除操作

删除操作可以参考二叉查找树的删除操作，其实就是分以下三种情况

1. 如果删除的value比tree->value大，那么继续往右边搜索

2. 如果删除的value比tree->value小，那么继续往左边搜索

3. 如果找到删除的value，那么又要分以下两种情况处理

1. 如果该节点有左右孩子的，那么用右子树的最小节点替代这个被删除的节点，然后再递归删除右子树的最小节点

2. 如果该节点只有一个左或者右孩子或者是没有孩子节点的，直接删除，返回相应的tree指针

删除操作，也是有可能造成树的不平衡。比如，删除下面这棵树的节点4，就会引起节点3的不平衡（左孩子的高为2，右孩子的高为0）



有一个很重要的一点，删除之前，树是平衡的，所以删除之后，不管删除节点有几个孩子，其左右子节点的高度差最多是2，不会超过2（删除节点的父节点或者是父父节点，再往上也是一样的），否则原来的树就是不平衡的，删除之后，无非有可能出现下面这四种情况









当删除之后，先要更新tree的高度，然后再判断tree是否失去平衡，如果失去平衡，再按照下面的算法调整

/* Update the height of tree */
tree->height = avl_tree_max(avl_tree_height(tree->lChild), avl_tree_height(tree->rChild)) + 1;

if(avl_tree_height(tree->lChild) - avl_tree_height(tree->rChild) == 2)
{
if(tree->lChild->rChild)
tree = avl_tree_double_rotate_with_left(tree);
else
tree = avl_tree_single_rotate_with_left(tree);
}
else if(avl_tree_height(tree->rChild)- avl_tree_height(tree->lChild) == 2)
{
if(tree->rChild->lChild)
tree = avl_tree_double_rotate_with_right(tree);
else
tree = avl_tree_single_rotate_with_right(tree);
}

查找操作

这个最简单，主要有三种情况：

1. 当查找value比tree->value小的时候，继续往左边查找

2. 当查找value比tree->value大的时候，继续往右边查找

3. 当查找value == tree->value时，返回

下面是上述操作的实现代码（下面代码有用到tree_visual_create.h，该头文件是将二叉树可视化，方便查看结果，具体可以参考二叉树的可视化）

avl_tree.h

#ifndef __AVL_TREE_H__
#define __AVL_TREE_H__

typedef int ElementType;

typedef struct AVL_TREE_T
{
ElementType value;
struct AVL_TREE_T * lChild;
struct AVL_TREE_T * rChild;
int height;
}AVL_TREE;

typedef AVL_TREE Node;
typedef AVL_TREE Position;

extern void avl_tree_main(void);

#endif

avl_tree.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "avl_tree.h"
#include "tree_visual_create.h"

int avl_tree_max(int h1, int h2)
{
if(h1 > h2)
return h1;
else
return h2;
}

int avl_tree_height(AVL_TREE * tree)
{
if(NULL == tree)
return -1;
else
return tree->height;
}

Node * avl_tree_find(AVL_TREE * tree, ElementType value)
{
Node * node = NULL;

if(tree)
{
if(tree->value == value)
node = tree;
else if(tree->value > value)
node = avl_tree_find(tree->lChild, value);
else if(tree->value < value)
node = avl_tree_find(tree->rChild, value);
}

return node;
}

Node * avl_tree_find_min(AVL_TREE * tree)
{
AVL_TREE * node = NULL;

if(tree)
{
if(tree->lChild)
node = avl_tree_find_min(tree->lChild);
else
node = tree;
}

return node;
}

Node * avl_tree_find_max(AVL_TREE * tree)
{
AVL_TREE * node = NULL;

if(tree)
{
if(tree->rChild)
node = avl_tree_find_max(tree->rChild);
else
node = tree;
}

return node;
}

Position * avl_tree_single_rotate_with_left(AVL_TREE * k2)
{
Position * k1;

k1 = k2->lChild;
k2->lChild = k1->rChild;
k1->rChild = k2;

k2->height = avl_tree_max(avl_tree_height(k2->lChild), avl_tree_height(k2->rChild)) + 1;
k1->height = avl_tree_max(avl_tree_height(k1->lChild), avl_tree_height(k1->rChild)) + 1;

return k1;
}

Position * avl_tree_single_rotate_with_right(AVL_TREE * k1)
{
Position * k2;

k2 = k1->rChild;
k1->rChild = k2->lChild;
k2->lChild = k1;

k1->height = avl_tree_max(avl_tree_height(k1->lChild), avl_tree_height(k1->rChild)) + 1;
k2->height = avl_tree_max(avl_tree_height(k2->lChild), avl_tree_height(k2->rChild)) + 1;

return k2;
}

Position * avl_tree_double_rotate_with_left(AVL_TREE * k3)
{
/* Rotate between k1 and k2 */
k3->lChild = avl_tree_single_rotate_with_right(k3->lChild);

/* Rotate between k2 and k3 */
return avl_tree_single_rotate_with_left(k3);
}

Position * avl_tree_double_rotate_with_right(AVL_TREE * k1)
{
/* Rotate between k2 and k3 */
k1->rChild = avl_tree_single_rotate_with_left(k1->rChild);

/* Rotate between k1 and k2 */
return avl_tree_single_rotate_with_right(k1);
}

AVL_TREE * avl_tree_insert(AVL_TREE * tree, ElementType value)
{
if(NULL == tree)
{
tree = (AVL_TREE *)malloc(sizeof(AVL_TREE));
if(NULL == tree)
printf("AVL_TREE malloc failed\n");
else
{
tree->value = value;
tree->height = 0;
tree->lChild = tree->rChild = NULL;
}
}
else if(tree->value > value)
{
tree->lChild = avl_tree_insert(tree->lChild, value);
if(avl_tree_height(tree->lChild) - avl_tree_height(tree->rChild) == 2)
{
if(value < tree->lChild->value)
tree = avl_tree_single_rotate_with_left(tree);
else
tree = avl_tree_double_rotate_with_left(tree);
}
}
else if(tree->value < value)
{
tree->rChild = avl_tree_insert(tree->rChild, value);
if(avl_tree_height(tree->rChild)- avl_tree_height(tree->lChild) == 2)
{
if(value > tree->rChild->value)
tree = avl_tree_single_rotate_with_right(tree);
else
tree = avl_tree_double_rotate_with_right(tree);
}
}

tree->height = avl_tree_max(avl_tree_height(tree->lChild), avl_tree_height(tree->rChild)) + 1;

return tree;
}

Node * avl_tree_delete(AVL_TREE * tree, ElementType value)
{
AVL_TREE * temp = NULL;

if(NULL == tree)
{
printf("Not found the element\n");
}
else if(value > tree->value)        /* Go Right */
{
tree->rChild = avl_tree_delete(tree->rChild, value);
}
else if(value < tree->value)       /* Go Left */
{
tree->lChild = avl_tree_delete(tree->lChild, value);
}
else if(tree->lChild && tree->rChild)       /* Two Children */
{
temp = avl_tree_find_min(tree->rChild);

tree->value = temp->value;
tree->rChild = avl_tree_delete(tree->rChild, tree->value);
}
else                /* one or zero Children */
{
temp = tree;
if(NULL == tree->lChild)
{
tree = tree->rChild;
}
else if(NULL == tree->rChild)
{
tree = tree->lChild;
}

free(temp);
}

if(tree)        /* Ignore the free node */
{
/* Update the height of tree */
tree->height = avl_tree_max(avl_tree_height(tree->lChild), avl_tree_height(tree->rChild)) + 1;

if(avl_tree_height(tree->lChild) - avl_tree_height(tree->rChild) == 2)
{
if(tree->lChild->rChild)
tree = avl_tree_double_rotate_with_left(tree);
else
tree = avl_tree_single_rotate_with_left(tree);
}
else if(avl_tree_height(tree->rChild)- avl_tree_height(tree->lChild) == 2)
{
if(tree->rChild->lChild)
tree = avl_tree_double_rotate_with_right(tree);
else
tree = avl_tree_single_rotate_with_right(tree);
}
}

return tree;
}

void avl_tree_destroy(AVL_TREE * tree)
{
if(tree)
{
if(tree->lChild)
avl_tree_destroy(tree->lChild);
if(tree->rChild)
avl_tree_destroy(tree->rChild);

free(tree);
}
}

void avl_tree_main(void)
{
AVL_TREE * tree = NULL;
//int i=0;

//for(i=1; i<=127; i++)
//    tree = avl_tree_insert(tree, i);
#if 0
tree = avl_tree_insert(tree, 7);
tree = avl_tree_insert(tree, 6);
tree = avl_tree_insert(tree, 10);
tree = avl_tree_insert(tree, 5);
tree = avl_tree_insert(tree, 13);
tree = avl_tree_insert(tree, 8);
tree = avl_tree_insert(tree, 11);
#endif
#if 0
tree = avl_tree_insert(tree, 5);
tree = avl_tree_insert(tree, 3);
tree = avl_tree_insert(tree, 6);
tree = avl_tree_insert(tree, 4);
#endif
#if 0
tree = avl_tree_insert(tree, 5);
tree = avl_tree_insert(tree, 2);
tree = avl_tree_insert(tree, 8);
tree = avl_tree_insert(tree, 1);
tree = avl_tree_insert(tree, 4);
tree = avl_tree_insert(tree, 7);
tree = avl_tree_insert(tree, 3);
#endif
#if 0
tree = avl_tree_insert(tree, 7);
tree = avl_tree_insert(tree, 6);
tree = avl_tree_insert(tree, 8);
tree = avl_tree_insert(tree, 5);
tree = avl_tree_insert(tree, 9);
tree = avl_tree_insert(tree, 10);
#endif
#if 0
tree = avl_tree_insert(tree, 8);
tree = avl_tree_insert(tree, 3);
tree = avl_tree_insert(tree, 10);
tree = avl_tree_insert(tree, 2);
tree = avl_tree_insert(tree, 5);
tree = avl_tree_insert(tree, 9);
tree = avl_tree_insert(tree, 11);
tree = avl_tree_insert(tree, 1);
tree = avl_tree_insert(tree, 4);
tree = avl_tree_insert(tree, 6);
tree = avl_tree_insert(tree, 12);
tree = avl_tree_insert(tree, 7);
#endif
#if 1
tree = avl_tree_insert(tree, 3);
tree = avl_tree_insert(tree, 2);
tree = avl_tree_insert(tree, 4);
tree = avl_tree_insert(tree, 1);
#endif
tree_visual_create(tree, "tree_insert.dot");

Node * min = avl_tree_find_min(tree);
printf("min value : %d\n", min->value);

Node * max = avl_tree_find_max(tree);
printf("max value : %d\n", max->value);

Node * find = avl_tree_find(tree, 2);
if(find)
printf("find value : %d\n", find->value);
else
printf("Cannot find the value\n");

tree = avl_tree_delete(tree, 4);
tree_visual_create(tree, "tree_delete.dot");

avl_tree_destroy(tree);
}