AVL树

AVL树

在二叉查找树（BST）中，频繁的插入操作可能会让树的性能发生退化，因此，需要加入一些平衡操作，使树的高度达到理想的O(logn)，这就是AVL树出现的背景。注意，AVL树的起名来源于两个发明者：Adel'son-Vel'skii 和 Landis。

AVL树除了具备BST树的基本特征之外，还具有一个非常重要的特点：

如果将一个节点的左、右子树的高度差定义为该节点的平衡因子，则AVL树的任意一个节点的平衡因子只有0、-1、1 三种取值。

可以采用递归的方法来判断一个BST树是不是AVL树：

typedef struct _pnode
{
int data;
int height;
struct _pnode *left;
struct _pnode *right;
} pnode;

static int TreeDepth (pnode p)
{
if (!p) return 0;

int nLeft = TreeDepth(p->left);
int nRight = TreeDepth(p->right);

return (nLeft > nRight) ? (nLeft+1) : (nRight+1);
}

static int IsBalanced(pnode root)
{
if (NULL == root)
return 1;

int left = TreeDepth(root->left);
int right = TreeDepth(root->right);

int diff = left - right;

if (diff > 1 || diff < -1) {
return 0;
}

return IsBalanced(root->left) && IsBalanced(root->right);
}

递归法的代码虽然简洁，但同一个结点会被重复遍历多次，因此效率并不高。

用后序遍历的方式遍历二叉树的每一个结点，在遍历到一个结点之前我们已经遍历了它的左右子树。
只要在遍历每个结点的同时记录它的深度，就可以一边遍历一边判断每个结点是否平衡。

static int IsBalanced2(pnode root, int* pDepth)
{
int left, right;

if (root == NULL) {
*pDepth = 0;
return 1;
}

if (IsBalanced2(root->left, &left)
&& IsBalanced2(root->right, &right)) {

int diff = left - right;
if (diff <= 1 && diff >= -1) {
*pDepth = 1 + (left > right ? left : right);
return 1;
}
}

return 0;
}

那么，AVL树是如何保证其平衡呢？当插入一个节点时，首先检查是否因插入而破坏了平衡，若破坏，则找出其中的最小不平衡子树，在保持二叉排序树特性的情况下，调整最小不平衡子树中节点之间的关系（通过左旋转和右旋转实现），以达到新的平衡。

注意：最小不平衡子树指离插入节点最近且以平衡因子的绝对值大于1的节点作为根的子树。

树的旋转

有四种情况可能导致二叉查找树不平衡，分别为：

LL： 插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因子由1变为2

LR：插入一个新节点到根节点的左子树（Left）的右子树（Right），导致根节点的平衡因子由1变为2

RL：插入一个新节点到根节点的右子树（Right）的左子树（Left），导致根节点的平衡因子由-1变为-2

RR：插入一个新节点到根节点的右子树（Right）的右子树（Right），导致根节点的平衡因子由-1变为-2

如下图，是四种不平衡的情况：



1和4两种情况是对称的，这两种情况的旋转算法是一致的，只需要经过一次旋转就可以达到目标，我们称之为单旋转。2和3两种情况也是对称的，这两种情况的旋转算法也是一致的，需要进行两次旋转，我们称之为双旋转。

单旋转是针对于LL和RR这两种情况的解决方案，这两种情况是对称的，只要解决了LL这种情况，RR就很好办了。
下图是LL情况的解决方案，节点k2不满足平衡特性，因为它的左子树k1比右子树Z深2层，而且k1子树中，更深的一层的是k1的左子树X子树，所以属于LL情况。



为使树恢复平衡，我们把k2变成这棵树的根节点，因为k2大于k1，把k2置于k1的右子树上，而原本在k1右子树的Y大于k1，小于k2，就把Y置于k2的左子树上，这样既满足了二叉查找树的性质，又满足了平衡二叉树的性质。
这样的操作只需要一部分指针改变，结果我们得到另外一颗二叉查找树，它是一棵AVL树，因为X向上一移动了一层，Y还停留在原来的层面上，Z向下移动了一层。整棵树的新高度和之前没有在左子树上插入的高度相同，插入操作使得X高度长高了。因此，由于这颗子树高度没有变化，所以通往根节点的路径就不需要继续旋转了。

LL单旋转：

void SingRotateLeft(pnode* &k2)
{
pnode *k1;

k1 = k2->left;
k2->left = k1->right;
k1->right = k2;

k2->height = Max(TreeDepth(k2->left), TreeDepth(k2->right)) + 1;
k1->height = Max(TreeDepth(k1->left), k2->height) + 1;
}

RR单旋转类似，

void SingRotateRight(pnode* &k2)
{
pnode *k1;

k1 = k2->right;
k2->right = k1->left;
k1->left = k2;

k2->height = Max(TreeDepth(k2->left), TreeDepth(k2->right))+1;
k1->height = Max(TreeDepth(k1->right), k2->height)+1;
}
~

对于LR和RL这两种情况，单旋转不能使它达到一个平衡状态，要经过两次旋转。双旋转是针对于这两种情况的解决方案，同样的，这样两种情况也是对称的，只要解决了LR这种情况，RL就很好办了。
下图是LR情况的解决方案，节点k3不满足平衡特性，因为它的左子树k1比右子树Z深2层，而且k1子树中，更深的一层的是k1的右子树k2子树，所以属于LR情况。



第一次旋转是围绕"k1"进行的"RR旋转"，第二次是围绕"k3"进行的"LL旋转"。
LR的旋转代码

void DoubleRotateLR(pnode* &k3)
{
SingRotateRight(k3->left);
SingRotateLeft(k3);
}

RL也是类似的，

void DoubleRotateRL(pnode* &k3)
{
SingRotateLeft(k3->right);
SingRotateRight(k3);
}

插入

插入的方法和二叉查找树基本一样，区别是，插入完成后需要从插入的节点开始维护一个到根节点的路径，每经过一个节点都要维持树的平衡。维持树的平衡要根据高度差的特点选择不同的旋转算法。

void insert(pnode* &node, int key)
{
// 如果节点为空,就在此节点处加入key信息
if (node == NULL) {
node = (pnode*) malloc(sizeof(pnode));
memset(node, 0, sizeof(pnode));
node->data = key;

// 如果key小于节点的值,就继续在节点的左子树中插入key
} else if (node->data > key) {

insert(node->left, key);

// 如果高度之差为2的话就失去了平衡,需要旋转
if (2 == TreeDepth(node->left) - TreeDepth(node->right)) {

if (key < node->left->data) {
SingRotateLeft(node);

} else {
DoubleRotateLR(node);
}
}

//如果key大于节点的值,就继续在节点的右子树中插入key
} else if (node->data < key) {

insert(node->right, key);

if (2 == TreeDepth(node->right)-TreeDepth(node->left)) {

if (key > node->right->data) {
SingRotateRight(node);

} else {
DoubleRotateRL(node);
}
}

} else {
// 如果相等
printf("error: key depulicated!");
}

node->height = Max(TreeDepth(node->left), TreeDepth(node->right)) + 1;
}

删除