AVL树

定义：一棵空二叉树是AVL树，如果T是非空二叉树，TL和TR分别是其左子树和右子树，

则当且仅当TL和TR都为AVL树且|HL-HR|<=1时，T是AVL树。

由定义知道一个AVL树的任何节点的左右子树的高度之差不超过1，这是AVL树最基本的特征。

#include <stdio.h>
#include <malloc.h>

#define LH  1 //左高
#define EH  0 //等高
#define RH  -1//右高 
#define TRUE 1
#define FALSE 0

typedef int ElemType;
typedef struct BSTNode
{
    ElemType key;
    int bf;
    struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;  //平衡树的定义
//中序遍历
void InOrderTraverse(BSTree root)
{
    if(root)
    {
        InOrderTraverse(root->lchild);
        printf("%d ",root->key);
        InOrderTraverse(root->rchild);
    }
}
//前序遍历
void PreOrderTraverse(BSTree root)
{
    if(root)
    {
        printf("%d ",root->key);
        PreOrderTraverse(root->lchild);
        PreOrderTraverse(root->rchild);
    }
}
//右旋 如图1
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=T->lchild;
    switch(lc->bf)
    {
    case LH:
        T->bf=lc->bf=EH;
        R_Rotate(T);
        break;
    case RH:
        BSTree rd=lc->rchild;
        switch(rd->bf)
        {
        case LH:     //如图2所示
            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 rc=T->rchild;
    switch(rc->bf)
    {
    case RH:
        T->bf=rc->bf=EH;
        L_Rotate(T);
        break;
    case LH:
        BSTree ld=rc->lchild;
        switch(ld->bf)
        {
        case RH:
            T->bf=LH;
            rc->bf=EH;
            break;
        case EH:
            T->bf=rc->bf=EH;
            break;
        case LH:
            T->bf=EH;
            rc->bf=RH;
            break;
        }
        ld->bf=EH;
        R_Rotate(T->rchild);
        L_Rotate(T);
        break;
    }
}
//在平衡二叉排序树中插入一个结点
int InsertAVL(BSTree &t,ElemType e,bool &taller)
{
    if(!t)
    {
        t=(BSTree)malloc(sizeof(BSTNode));
        t->key=e;
        t->lchild=t->rchild=NULL;
        t->bf=EH;
        taller=TRUE;
    }
    else
    {
        if(e==t->key)
        {
            taller=FALSE;
            return 0;
        }
        if(e<t->key)
        {
            if(!InsertAVL(t->lchild,e,taller))
                return 0;          //未插入
            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 0;          //未插入
            if(taller)
            {
                switch(t->bf)
                {
                case RH:
                    RightBalance(t);
                    taller=FALSE;
                    break;
                case EH:
                    t->bf=RH;
                    taller=TRUE;
                    break;
                case LH:
                    t->bf=EH;
                    taller=FALSE;
                    break;
                }
            }
        }
    }
    return 1;
}
//查找key，若没找到，则返回NULL
BSTree Search(BSTree t,ElemType key)
{
     BSTree p=t;
     while(p)
     {
         if(p->key==key)
             return p;
         else if(p->key<key)
             p=p->rchild;
         else
             p=p->lchild;
     }
     return p;
}
/**/
int main(int argc,char *argv[])
{
    BSTree root=NULL,r;
    bool taller=FALSE;
    int array[]={13,24,37,90,53};
    for(int i=0;i<5;i++)
        InsertAVL(root,array[i],taller);
    printf("inorder traverse\n");
    InOrderTraverse(root);

    printf("\npreorder traverse\n");
    PreOrderTraverse(root);

    printf("\nsearch key\n");
    r=Search(root,37);
    if(r)
    {
        printf("%d\n",r->key);
    }
    else
    {
        printf("not find!\n");
    }
}

图1：

图2：

输出结果：