数据结构：自平衡二叉查找树（AVL树）

（1）二叉查找树的定义

在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。

二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。每一棵子树的根叫做根r的儿子，而r是每一棵子树的根的父亲。

具有N个节点的每一棵二叉树都将需要N+1个NULL指针。对于树中的每个结点X，它的左子树中所有关键字值小于X的关键字值，而它的右子树中所有关键字值大于X的关键字值。

二叉查找树的平均深度为O（log N）。
（2）AVL树与非自平衡二叉查找树

相比较于非自平衡二叉查找树，AVL树是带有平衡条件的二叉查找树。这个平衡条件必须需要保持。对于一棵AVL树，每个结点的左子树和右子树的高度最多差1。在这里，我们将空树的高度定义为-1。所以一个问题在于，插入一个结点可能破坏AVL树的特性，所以我们可以通过对树的修正来完成，我们称其为旋转。

（3）AVL树的旋转

由于任意结点最多有两个儿子，因此高度不平衡时，a点的两个子树的高度差为2。容易看出，这种不平衡容易可能出现在下面4种情形。

1、对a的左儿子的左子树进行一次插入。

2、对a的左儿子的右子树进行一次插入。

3、对a的右儿子的左子树进行一次插入。

4、对a的右儿子的右子树进行一次插入。

第一种情况是插入发生在外边的情况（即左-左的情况或者右-右的情况），该情况可通过对树的一次单旋转而完成调整。第二种则是发生在内部的情形。（即左-右情况或右-左情况），该情况可通过一次双旋转完成。

（4）AVL树的操作例程。

1、声明

#include <stdio.h>
#include <stdlib.h>

#ifndef _AVLTREE_H
#define _AVLTREE_H
#define DATA_TYPE int

struct AvlNode;
typedef struct AvlNode *Position;
typedef struct AvlNode *Tree;

Tree Delete_tree(Tree T);							//删除树
Tree New_tree(DATA_TYPE X);							//新建一棵树
Position Find(Tree T, DATA_TYPE X);					//查找
Position Find_Min(Tree T);							//查找树的最小值
Position Find_Max(Tree T);							//查找树的最大值
Position Insert(Tree T, DATA_TYPE X);				//插入结点
Position Delete(Tree T, DATA_TYPE X);				//
Position Print_tree(Tree T);						//先序遍历二叉树
static int Height(Position P);						//计算当前结点的高度
static Position Single_Rotate_left(Position K2);	//左左单旋转
static Position Single_Rotate_right(Position K2);	//右右单旋转
static Position Double_Rotate_left(Position K3);	//左右双旋转
static Position Double_Rotate_right(Position K3);	//右左双旋转
static int Max(int a, int b);
static Position Fix(Position K2);
struct AvlNode
{
DATA_TYPE num;
Tree left;
Tree right;
int height;
};

#endif

2、结点的高度与判定最大值函数

Tree Delete_tree(Tree T)
{
if (T != NULL)
{
Delete_tree(T->left);
Delete_tree(T->right);
free(T);
}
return NULL;
}

static int Height(Position P)
{
if (P == NULL)	//如果树为空则高度为-1
return -1;
else
return P->height;
}

3、新建查找树与删除查找树

Tree New_tree(DATA_TYPE X)
{
Position first;
first = malloc(sizeof(struct AvlNode));
if (first == NULL)
return NULL;
first->num = X;
first->right = NULL;
first->left = NULL;
return first;
}

Tree Delete_tree(Tree T)
{
if (T != NULL)
{
Delete_tree(T->left);
Delete_tree(T->right);
free(T);
}
return NULL;
}

4、查找目标节点、查找最小结点和查找最大结点

Position Find(Tree T, DATA_TYPE X)
{
while (T != NULL)
{
if (X < T->num)
T = T->left;
else if (X > T->num)
T = T->left;
else return T;
}
return NULL;
}

Position Find_Min(Tree T)
{
if (T != NULL)
{
for (; T->left != NULL; T = T->left);
return T;
}
return T;
}

Position Find_Max(Tree T)
{
if (T != NULL)
{
for (; T->left != NULL; T = T->right);
return T;
}
return NULL;
}

5、插入结点

Position Insert(Tree T, DATA_TYPE X)
{
if (T == NULL)	//成功找出插入位置
{
T = malloc(sizeof(struct AvlNode));
if (T == NULL)
return NULL;
else
{
T->num = X;
T->height = 0;
T->left = T->right = NULL;
}
}
else if (X < T->num)			//如果待插入结点小于该节点，则移向左子树
{
T->left = Insert(T->left, X);
if (Height(T->left) - Height(T->right) == 2)//判定左子树高度与右子树高度差为2
if (X < T->left->num)		//判定情况属于L-L还是L-R
T = Single_Rotate_left(T);
else
T = Double_Rotate_left(T);
}
else if (X > T->num)			//如果待插入结点大于该节点，则移向右子树
{
T->right = Insert(T->right, X);
if (Height(T->right) - Height(T->left) == 2)//判定右子树高度与左子树高度差为2
if (X > T->right->num)		//判定情况属于R-R还是R-L
T = Single_Rotate_right(T);
else
T = Double_Rotate_right(T);
}
T->height = Max(Height(T->left), Height(T->right)) + 1;	//更新结点高度
return T;
}

6、删除结点

Position Delete(Tree T, DATA_TYPE X)
{
Position TmpCell;

if (T == NULL)
{
printf("Element not found!!\n");
return NULL;
}
else if (T->num > X)						//往左边查找元素X
T->num = Delete(X, T->left);
else if (T->num < X)						//往右边查找元素X
T->num = Delete(X, T->right);
else if (T->left && T->right)				//元素找到了并且左右子树都不为空
{
TmpCell = FindMin(T->right);		    //将要删除的节点用右子树中的最小节点代替
T->num = TmpCell->num;
T->right = Delete(T->num, T->right);
}
else                                      //元素找到了并且左右子树有一个为空
{
TmpCell = T;
if (T->left == NULL)
T = T->right;
else if (T->right == NULL)
T = T->left;

free(TmpCell);
}

if (T != NULL)
{
T->height = Max(Height(T->left), Height(T->right)) + 1;		//删除完节点之后要更新高度
//判断是否在节点T处失去平衡
if ((Height(T->left) - Height(T->right) >= 2) || (Height(T->right) - Height(T->left) >= 2))
{
T = Fix(T);
T->height = Max(Height(T->left), Height(T->right)) + 1;
}
}
return T;
}

static Position Fix(Position K2)
{
if (Height(K2->left) > Height(K2->right))
{
//K2左儿子的左儿子的高度大于K2的左儿子的右儿子的高度, 执行左单旋转, 否则执行左-右双旋转
if (Height(K2->left->left) > Height(K2->left->right))
K2 = Single_Rotate_Left(K2);
else if (Height(K2->left->left) < Height(K2->left->right))
K2 = Double_Rotate_Left(K2);
}
else if (Height(K2->left) < Height(K2->right))
{
//K2右儿子的右儿子的高度大于K2的右儿子的左儿子的高度, 执行右单旋转, 否则执行右-左双旋转
if (Height(K2->right->right) > Height(K2->right->left))
K2 = Single_Rotate_Right(K2);
else if (Height(K2->right->right) < Height(K2->right->left))
K2 = Double_Rotate_Right(K2);
}

return K2;
}

7、先序打印树中的结点

Position Print_tree(Tree T)
{
if (T == NULL)
{
printf("The Tree is empty.\n");
return NULL;
}
else if (T->left != NULL && T->right != NULL)
{
printf("%d ", T->num);
T->left = Print_tree(T->left);
T->right = Print_tree(T->right);
}
else if (T->left != NULL && T->right == NULL)
{
printf("%d ", T->num);
T->left = Print_tree(T->left);
}
else if (T->left == NULL && T->right != NULL)
{
printf("%d ", T->num);
T->right = Print_tree(T->right);
}
else if (T->left == NULL && T->right == NULL)
printf("%d ", T->num);
return T;
}

8、树的旋转

左左单旋转

static Position Single_Rotate_left(Position K2)
{
Position 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->right) + 1;
return K1;
}

右右单旋转

static Position Single_Rotate_right(Position K2)
{
Position K1;
K1 = K2->right;
K2->right = K1->left;
K1->left = K2;

K2->height = Max(Height(K2->right), Height(K2->left)) + 1;
K1->height = Max(Height(K1->right), K2->height) + 1;
return K1;
}

左右双旋转

static Position Double_Rotate_left(Position K3)
{
K3->left = Single_Rotate_right(K3->left);
return Single_Rotate_left(K3);
}

右左双旋转

static Position Double_Rotate_right(Position K3)
{
K3->right = Single_Rotate_left(K3->right);
return Single_Rotate_right(K3);
}