数据结构——平衡二叉树

一、平衡二叉树的定义

　　平衡二叉树（AVL 树）仍然是一棵二叉查找树，只是在其基础上增加了“平衡”的要求。所谓平衡是指，对 AVL 树的任意结点来说，其左子树与右子树的高度之差的绝对值不超过 1，其中左子树与右子树的高度之差称为该结点的平衡因子。

　　由于需要对每个结点都得到平衡因子，因此需要在树的结构中加入一个变量 height，用来记录以当前结点为根结点的子树的高度：

// 平衡二叉树结构体 
struct node {
    int v, height;            // v 为结点权值， height 为当前子树高度
    node *lchild, *rchild;    // 左右孩子结点地址 
};

　　在这种定义下，如果需要新建一个结点，就可以采用如下写法：

// 平衡二叉树新建结点
node* newNode(int v) {
    node* Node = (node*)malloc(sizeof(node));    // 申请地址空间 
    Node->v = v;                                // 结点权值为 v 
    Node->height = 1;                            // 结点高度初始为 1 
    Node->lchild = Node->rchild = NULL;            // 初始状态下没有左右孩子 
    return Node;
} 

　　可通过下面的函数获取结点 root 所在子树的当前高度：

// 获取以 root 为根结点的子树的当前高度
int getHeight(node* root) {
    if(root == NULL)    return 0;    // 空树高度为 0
    return root->height; 
}

　　于是根据定义，可以通过下面的函数计算平衡因子：

// 计算结点 root 的平衡因子
int getBalanceFactor(node* root) {
    // 左子树高度减右子树高度
    return getHeight(root->lchild) - getHeight(root->rchild); 
} 

　　显然，结点 root 所在子树的 height 等于其左子树的 height 与右子树的 height 的较大值加 1，因此可通过下面的函数来更新 height：

// 更新结点 root 的高度
void updateHeight(node* root) {
    // 根结点高度为左右子树高度较大值 +1 
    int lHeight = getHeight(root->lchild), rHeight = getHeight(root->rchild);
    int max = lHeight > rHeight ? lHeight : rHeight;
    root->height = max + 1;
} 

二、平衡二叉树的基本操作

　　和二叉查找树相同，AVL 树的基本操作有查找、插入、建树以及删除，由于删除操作较为复杂，因此主要介绍 AVL 树的查找、插入和建立。

　　1. 查找操作

　　由于 AVL 树是一棵二叉查找树，因此其查找操作的做法与二叉查找树相同。代码如下：

// 查找平衡二叉树中数据域为 x 的结点 
void search(node* root, int x) {
    if(root == NULL) {    // 空树，查找失败 
        printf("search failed
");
        return; 
    }
    if(x == root->v) {    // 查找成功，访问之 
        printf("search success %d
", root->v); 
    } else if(x < root->v) {        // x 比根结点的数据域小，往左子树查找 
        search(root->lchild, x);
    } else {
        search(root->rchild, x);    // x 比根结点的数据域大，往右子树查找
    } 
} 

　　2. 插入操作

　　先来看一下几个插入问题需要用到的几个操作。

　　左旋，调整步骤如下：

1. 1.  让 B 的左子树 ♦ 成为 A 的右子树。
   2.  让 A 成为 B 的左子树
   3.  将根结点设定为结点 B　　　　

　　

　　对应的代码如下：

// 左旋
void L(node** root) {
    node* temp = (*root)->rchild;    // root指向A,temp指向B
    (*root)->rchild = temp->lchild;    // 步骤 1
    temp->lchild = *root;            // 步骤 2
    updateHeight(*root);                // 更新高度
    updateHeight(temp);
    (*root) = temp;                    // 步骤 3 
} 

　　右旋的实现步骤和左旋基本相同：

1. 1.  让 A 的右子树 ♦ 成为 B 的左子树。
   2.  让 B 成为 A 的右子树。
   3.  将根结点设定为结点 A。　　　　

　　

　　代码如下：

// 右旋
void R(node** root) {
    node* temp = (*root)->lchild;    // root指向A,temp指向B
    (*root)->lchild = temp->rchild;    // 步骤 1
    temp->rchild = *root;            // 步骤 2
    updateHeight(*root);                // 更新高度
    updateHeight(temp);
    (*root) = temp;                    // 步骤 3 
} 

　　关于旋转的讨论到此为止，接下来开始讨论 AVL 树的插入操作。

　　显然，只有在从根结点到该插入结点的路径上的结点才可能发生平衡因子变化，因此只需对这条路径上失衡的结点进行调整。可以证明，只要把最靠近插入结点的失衡结点调整到正常，路径上的所有结点就都会平衡。

　　假设最靠近插入结点的失衡结点是 A，显然它的平衡因子只可能是 2 或者 -2。很容易发现这两种情况完全对称，因此主要讨论结点 A 的平衡因子是 2 的情形。

　　于是以结点 A 为根结点的子树一定是下图的两种形态 LL 型与 LR 型之一。

　　

　　现在考虑怎样调整这两种树型，才能使树平衡。

　　先考虑 LL 型。可以把以 C 为根结点的子树看作一个整体，然后以结点 A 作为 root 进行右旋，便可以达到平衡，如下图：

　　

　　然后考虑 LR 型，可以先忽略结点 A，以结点 C 为 root 进行左旋，就可以把情况转化为 LL 型，然后按上面 LL 型的做法进行一次右旋即可，如下图所示：

　　

　　至此，结点 A 的平衡因子是 2 的情况已经讨论清楚，平衡因子是 -2 的情况完全对称。

　　对 LL 型、LR 型、RR型、RL型的调整方法汇总如下：

　　

　　由于需要从插入的结点开始从下往上判断是否失衡，因此需要在每个 insert 函数之后更新当前子树的高度，并在之后根据树型进行平衡操作，代码如下：

// 插入权值为 v 的结点
void insert(node** root, int v) {
    if((*root) == NULL) {        // 到达插入位置 
        (*root) = newNode(v);
        return;
    }
    if(v < (*root)->v) {        // v 比根结点权值小 
        insert(&(*root)->lchild, v);        // 往左子树插入 
        updateHeight(*root);                // 更新树高 
        if(getBalanceFactor(*root) == 2) {
            if(getBalanceFactor((*root)->lchild) == 1) {    // LL 型 
                R(*root); 
            } else if(getBalanceFactor((*root)->lchild) == -1) {    // LR 型 
                L(&(*root)->lchild);
                R(root); 
            }
        } 
    } else {                    // v 比根结点权值大 
        insert(&(*root)->rchild, v);        // 往右子树插入 
        updateHeight(*root);                // 更新树高 
        if(getBalanceFactor(*root) == -2) {
            if(getBalanceFactor((*root)->rchild) == -1) {    // RR 型 
                L(root); 
            } else if(getBalanceFactor((*root)->rchild) == 1) {    // RL 型 
                R(&(*root)->rchild);
                L(root); 
            }
        }     
    }
} 

　　3.  AVL 树的建立

　　有了上面插入操作的基础，AVL 树的建立就非常简单了，因此只需依次插入 n 个结点即可。代码如下：

// AVL 树的建立 
node* create(int data[], int n) {
    node* root = NULL;        // 新建根结点 root
    int i;
    for(i=0; i<n; ++i) {
        insert(&root, data[i]);        // 将 data 中数据依次插入AVL树 
    } 
    return root;            // 返回根结点 
}

　　完整的测试代码如下：

/*
    平衡二叉树 
*/

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>

// 平衡二叉树结构体 
typedef struct _node {
    int v, height;            // v 为结点权值， height 为当前子树高度
    struct _node *lchild, *rchild;    // 左右孩子结点地址 
} node;

// 平衡二叉树新建结点
node* newNode(int v) {
    node* Node = (node*)malloc(sizeof(node));    // 申请地址空间 
    Node->v = v;                                // 结点权值为 v 
    Node->height = 1;                            // 结点高度初始为 1 
    Node->lchild = Node->rchild = NULL;            // 初始状态下没有左右孩子 
    return Node;
} 

// 获取以 root 为根结点的子树的当前高度
int getHeight(node* root) {
    if(root == NULL)    return 0;    // 空树高度为 0
    return root->height; 
} 

// 计算结点 root 的平衡因子
int getBalanceFactor(node* root) {
    // 左子树高度减右子树高度
    return getHeight(root->lchild) - getHeight(root->rchild); 
} 

// 更新结点 root 的高度
void updateHeight(node* root) {
    // 根结点高度为左右子树高度较大值 +1 
    int lHeight = getHeight(root->lchild), rHeight = getHeight(root->rchild);
    int max = lHeight > rHeight ? lHeight : rHeight;
    root->height = max + 1;
} 

// 查找平衡二叉树中数据域为 x 的结点 
void search(node* root, int x) {
    if(root == NULL) {    // 空树，查找失败 
        printf("search failed
");
        return; 
    }
    if(x == root->v) {    // 查找成功，访问之 
        printf("search success %d
", root->v); 
    } else if(x < root->v) {        // x 比根结点的数据域小，往左子树查找 
        search(root->lchild, x);
    } else {
        search(root->rchild, x);    // x 比根结点的数据域大，往右子树查找
    } 
} 

// 左旋
void L(node** root) {
    node* temp = (*root)->rchild;    // root指向A,temp指向B
    (*root)->rchild = temp->lchild;    // 步骤 1
    temp->lchild = *root;            // 步骤 2
    updateHeight(*root);                // 更新高度
    updateHeight(temp);
    (*root) = temp;                    // 步骤 3 
} 

// 右旋
void R(node** root) {
    node* temp = (*root)->lchild;    // root指向A,temp指向B
    (*root)->lchild = temp->rchild;    // 步骤 1
    temp->rchild = *root;            // 步骤 2
    updateHeight(*root);                // 更新高度
    updateHeight(temp);
    (*root) = temp;                    // 步骤 3 
} 

// 插入权值为 v 的结点
void insert(node** root, int v) {
    if((*root) == NULL) {        // 到达插入位置 
        (*root) = newNode(v);
        return;
    }
    if(v < (*root)->v) {        // v 比根结点权值小 
        insert(&(*root)->lchild, v);        // 往左子树插入 
        updateHeight(*root);                // 更新树高 
        if(getBalanceFactor(*root) == 2) {
            if(getBalanceFactor((*root)->lchild) == 1) {    // LL 型 
                R(*root); 
            } else if(getBalanceFactor((*root)->lchild) == -1) {    // LR 型 
                L(&(*root)->lchild);
                R(root); 
            }
        } 
    } else {                    // v 比根结点权值大 
        insert(&(*root)->rchild, v);        // 往右子树插入 
        updateHeight(*root);                // 更新树高 
        if(getBalanceFactor(*root) == -2) {
            if(getBalanceFactor((*root)->rchild) == -1) {    // RR 型 
                L(root); 
            } else if(getBalanceFactor((*root)->rchild) == 1) {    // RL 型 
                R(&(*root)->rchild);
                L(root); 
            }
        }     
    }
} 

// AVL 树的建立 
node* create(int data[], int n) {
    node* root = NULL;        // 新建根结点 root
    int i;
    for(i=0; i<n; ++i) {
        insert(&root, data[i]);        // 将 data 中数据依次插入AVL树 
    } 
    return root;            // 返回根结点 
}

// 先序遍历
void preorder(node* root) {
    if(root == NULL) {
        return;        // 空树，递归边界 
    }
    printf("%d
", root->v);        // 访问该结点
    preorder(root->lchild);            // 访问左子树 
    preorder(root->rchild);            // 访问右子树  
}  

int main() {
    int data[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    node* root = NULL;
    root = create(data, 10);    // 创建 AVL 树 
    preorder(root);                // 先序遍历  
    search(root, 10);            // 在 root 中查找 10 
    return 0;
}