动态查找（二）——平衡二叉树

---

简介

平衡二叉树又叫做AVL树，是以AV和L两人的名字命名的。

什么是平衡二叉树？
除非它是一棵空树，不然它的左子树和右子树都是平衡二叉树，且左子树深度与右子树深度绝对值之差不超过1.

平衡二叉树比普通二叉平衡树的优势？
考虑极端情况，有序数组存储形成的二叉排序树，查找尾部数据时，查找次数较多。
平衡二叉树在索引过程中可以有效避免此情况，可以快速索引。

平衡二叉树比普通二叉平衡树的劣势？
需要额外的内存空间来存储结点深度信息；
每次插入数据时都需检查平衡状态，并对不平衡状态做左旋/右旋处理。
总的来说，平衡二叉树是以空间换时间的一种结构。
一家之言，姑且听之。

平衡二叉树相比于红黑树的劣势？
平衡二叉树实现绝对平衡，这对查找而言更加便捷；但是对于插入和删除就麻烦的多。
因此平衡二叉树适用于查找次数多、插入和删除次数少的数据。
相比于平衡二叉树，红黑树是一种弱平衡二叉树，能够均衡插入删除和查找的效率，因而应用更加广泛。
红黑树广泛应用于C++中的STL，比如map和set。

提示：对于原理上及代码上想不通的地方，举例画图，一目了然

---

代码

代码参考 http://c.biancheng.net/view/3432.html。

#include "iostream"
using namespace std;
#define LH 1
#define EH 0
#define RH -1
typedef struct BSTNode
{
    int data;
    int bf;
    BSTNode *lchild, *rchild;
}BSTNode, *BSTree;
void R_Rotate(BSTree* p)
{
    BSTree lc = (*p)->lchild;
    (*p)->lchild = lc->rchild;
    lc->rchild = *p;
    *p = lc;
}
void L_Rotate(BSTree* p)
{
    BSTree rc = (*p)->rchild;
    (*p)->rchild = rc->lchild;
    rc->lchild = *p;
    *p = rc;
}
void LeftBalance(BSTree* T)
{
    BSTree lc, rd;
    lc = (*T)->lchild;
    switch (lc->bf)
    {
        case LH:
            (*T)->bf = lc->bf = EH;
            R_Rotate(T);
            break;
        case RH:
            rd = lc->rchild;
            switch (rd->bf)
            {
                case LH:
                    (*T)->bf = RH;
                    lc->bf = EH;
                    break;
                case EH:
                    (*T)->bf = lc->bf = EH;
                    break;
                case RH:
                    (*T)->bf = EH;
                    lc->bf = LH;
                    break;
            }
            rd->bf = EH;
            L_Rotate(&(*T)->lchild);
            R_Rotate(T);
            break;
    }
}
void RightBalance(BSTree* T)
{
    BSTree lc, rd;
    lc = (*T)->rchild;
    switch (lc->bf)
    {
        case RH:
            (*T)->bf = lc->bf = EH;
            L_Rotate(T);
            break;
        case LH:
            rd = lc->lchild;
            switch (rd->bf)
            {
                case LH:
                    (*T)->bf = EH;
                    lc->bf = RH;
                    break;
                case EH:
                    (*T)->bf = lc->bf = EH;
                    break;
                case RH:
                    (*T)->bf = EH;
                    lc->bf = LH;
                    break;
            }
            rd->bf = EH;
            R_Rotate(&(*T)->rchild);
            L_Rotate(T);
            break;
    }
}
bool InsertAVL(BSTree* T, int e, bool *taller)
{
    if (!(*T))
    {
        (*T) = (BSTree)malloc(sizeof(BSTNode));
        (*T)->data = e;
        (*T)->bf = EH;
        (*T)->lchild = (*T)->rchild = NULL;
        *taller = true;
    }
    else if ((*T)->data == e)
    {
        *taller = false;
        return false;
    }
    else if ((*T)->data > e)
    {
        if (!InsertAVL(&(*T)->lchild, e, taller))
            return false;
        if (*taller)
        {
            switch ((*T)->bf)
            {
                case LH:
                    LeftBalance(T);
                    *taller = false;
                    break;
                case EH:
                    (*T)->bf = LH;
                    *taller = true;
                    break;
                case RH:
                    (*T)->bf = EH;
                    *taller = false;
                    break;
            }
        }
    }
    else
    {
        if(!InsertAVL(&(*T)->rchild, e, taller))
            return false;
        else if (*taller)
        {
            switch ((*T)->bf)
            {
                case LH:
                    (*T)->bf = EH;
                    *taller = false;
                    break;
                case EH:
                    (*T)->bf = RH;
                    *taller = true;
                    break;
                case RH:
                    RightBalance(T);
                    *taller = false;
                    break;
            }
        }
    }
    return true;
}
void InorderTra(BSTree root)
{
    if (root->lchild)
        InorderTra(root->lchild);
    cout << root->data << " ";
    if (root->rchild)
        InorderTra(root->rchild);
}
int main()
{
    int i, nArr[] = {1, 23, 45, 34, 98, 9, 4, 35, 23};
    BSTree root = NULL, pos;
    bool taller;
    for (i = 0; i < 9; i++)
    {
        InsertAVL(&root, nArr[i], &taller);
    }
    InorderTra(root);
}