二叉平衡树的基本操作（完整代码）

[code]#include<stdio.h>
#include<stdlib.h>

#define LH +1       //左树比右树高
#define EH 0        //等高
#define RH -1       //右树高
#define TURE 1
#define FALSE 0

typedef struct BiTNode
{
    int data;
    int bf;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

//右旋
void R_Rotate(BiTree *p)
{
    BiTree L;
    L=(*p)->lchild;     //*p的左子树赋值给L
    (*p)->lchild=L->rchild;     //L右字数挂到*p的左子树上
    L->rchild=(*p);     
    (*p)=L;     //用L替代原来位置
}

//左旋
void L_Rotate(BiTree *p)
{
    BiTree R;
    R=(*p)->rchild;
    (*p)->rchild=R->lchild;
    R->lchild=(*p);
    *p=R;
}

//左平衡旋转
void LeftBalance(BiTree *T)     //左子树的高度大于右子树的高度
{
    BiTree L,Lr;
    L=(*T)->lchild;     //将其左子树赋值给L
    switch(L->bf)       //判断L的平衡度
    {
    case LH:        //与*T相同，平衡度归零，直接右旋
            (*T)->bf=L->bf=EH;
            R_Rotate(T);
            break;
    case RH:        //与*T不同，去判断L的右子树（会替代*T的位置）
            Lr=L->rchild;
            switch(Lr->bf)
            {
            case LH:        
                (*T)->bf=RH;
                L->bf=EH;
                break;
            case EH:
                (*T)->bf=L->bf=EH;
                break;
            case RH:
                (*T)->bf=EH;
                L->bf=LH;
                break;
            }
        Lr->bf=EH;
        L_Rotate(&(*T)->lchild);
        R_Rotate(T);
    }
}

//右平衡旋转
void RightBalance(BiTree *T)        //同理
{
    BiTree R,Rr;
    R=(*T)->rchild;
    switch(R->bf)
    {
        case RH:
            (*T)->bf=R->bf=EH;
            L_Rotate(T);
            break;
        case LH:
            Rr=R->lchild;
            switch(Rr->bf)
            {
            case RH:
                (*T)->bf=LH;
                R->bf=EH;
                break;
            case EH:
                (*T)->bf=R->bf=EH;
                break;
            case LH:
                (*T)->bf=EH;
                R->bf=RH;
                break;
            }
        Rr->bf=EH;
        R_Rotate(&(*T)->rchild);
        L_Rotate(T);
    }
}

//插入
//布尔变量taller用来反应树长高与否
int Insert***L(BiTree *T,int e,int *taller)
{
    if(!*T)         //若*T为空，说明树中没有与要插入元素相等的树，构造新节点
    {
        *T=(BiTree)malloc(sizeof(BiTNode));
        (*T)->data=e;
        (*T)->lchild=(*T)->rchild=NULL;
        (*T)->bf=EH;
        *taller=TURE;       //构造新节点后，树长高了
    }
    else
    {
        if(e==(*T)->data)       //树中已有待插元素，树没长高，返回0
        {
            *taller=FALSE;
            return FALSE;
        }
        if(e<(*T)->data)        //递归部分：小于就遍历左子树继续
        {
            if(!(Insert***L(&(*T)->lchild,e,taller)))        //去插入左子树，未插入则返回0
                return FALSE;
            if(*taller)         //已插入，树长高
            {
                switch((*T)->bf)        //根据T原来的平衡度做判断
                {
                case LH:        //左大于右，插入后，左平衡处理，树未长高
                    LeftBalance(T);
                    *taller=FALSE;
                    break;
                case EH:        //相等，插入后左大于右，树长高
                    (*T)->bf=LH;
                    *taller=TURE;
                    break;
                case RH:        //右大于左，插入后，相等，树未长高
                    (*T)->bf=EH;
                    *taller=FALSE;
                    break;
                }
            }
        }
        else
        {
            if(!(Insert***L(&(*T)->rchild,e,taller)))        //插入右子树时的递归部分，同理
                return FALSE;
            if(*taller)
            {
                switch((*T)->bf)
                {
                case RH:
                    RightBalance(T);
                    *taller=FALSE;
                    break;
                case EH:
                    (*T)->bf=RH;
                    *taller=TURE;
                    break;
                case LH:
                    (*T)->bf=EH;
                    *taller=FALSE;
                    break;
                }
            }           
        }
    }
}

//中序输出
void InOrder(BiTree T)
{
    if(T)
    {
        InOrder(T->lchild);
        printf("%d ",T->data);
        InOrder(T->rchild);
    }
    else
        return;
}

void main()
{
    int i;
    int a[10]={3,2,1,4,5,6,7,10,9,8};
    BiTree T=NULL;
    int taller;
    for(i=0;i<10;i++)
    {
        Insert***L(&T,a[i],&taller);
    }
    InOrder(T);
}