查找三：平衡二叉树

//平衡二叉树
#include<iostream>
using namespace std;

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

// 对以p为根的二叉排序树作右旋处理，
// 处理之后p指向新的树根结点，即旋转处理之前的左子树的根结点 
void R_Rotate(BiTree *p)
{
    BiTree L;
    L = (*p)->lchild;
    (*p)->lchild  = L->rchild; //L的右子树挂接为P的左子树
    L->rchild = *p;
    *p = L;
}

// 对以p为根的二叉排序树作左旋处理，
// 处理之后p指向新的树根结点，即旋转处理之前的右子树的根结点 
void L_Rotate(BiTree *p)
{
    BiTree R;
    R = (*p)->rchild;
    (*p)->rchild = R->lchild;//R的左子树挂接为P的右子树
    R->lchild = *p;
    *p = R;
}

//  对以指针T所指结点为根的二叉树作左平衡旋转处理 
//  本算法结束时，指针T指向新的根结点 
void LeftBalance(BiTree *T)
{
    BiTree L, Lr;
    L = (*T)->lchild;
    switch(L->BF)
    {
        case 1: //新结点插在T的左孩子的左子树上,要作单右旋处理
            (*T)->BF = L->BF = 0; 
            R_Rotate(T); 
            break;
        case -1: //新结点插入在T的左孩子的右子树上,要作双旋处理
            Lr = L->rchild;
            switch(Lr->BF)
            {
                case 1:
                    (*T)->BF = -1;
                    L->BF = 0;
                    break;
                case 0:
                    (*T)->BF = 0;
                    L->BF = 0;
                    break;
                case -1:
                    (*T)->BF = 0;
                    L->BF = 1;
                    break;
            }
            Lr->BF = 0;
            L_Rotate(&(*T)->lchild);
            R_Rotate(T);
    }
}

// 对以指针T所指结点为根的二叉树作右平衡旋转处理，
// 本算法结束时，指针T指向新的根结点
void RightBalance(BiTree *T)
{
    BiTree R, Rl;
    R = (*T)->rchild;
    switch(R->BF)
    {
        case -1: //新结点插入在T的右孩子的右子树上,要作单左旋处理
            (*T)->BF = R->BF =0;
            L_Rotate(T);
            break;
        case 1: //新结点插入在T的右孩子的左子树上,要作双旋处理
            Rl = R->lchild;
            switch(Rl->BF)
            {
                case 1:
                    (*T)->BF = 0;
                    R->BF = -1;
                    break;
                case 0:
                    (*T)->BF = 0;
                    R->BF = 0;
                    break;
                case -1:
                    (*T)->BF = 1;
                    R->BF = 0;
                    break;
            }
            Rl->BF = 0;
            R_Rotate(&(*T)->rchild);
            L_Rotate(T);
    }
}

// 若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个 
// 数据元素为e的新结点，并返回1，否则返回0。若因插入而使二叉排序树 
// 失去平衡，则作平衡旋转处理，布尔变量taller反映T长高与否。 
bool InsertAVL(BiTree *T, int e, bool *taller)
{
    if(!*T) //插入新的结点
    {
        *T = new BiTNode;
        (*T)->data = e;
        (*T)->lchild = (*T)->rchild = NULL;
        (*T)->BF = 0;
        *taller = true; //树长高
    }
    else
    {
        if(e == (*T)->data) //树中存在则不再插入
        {
            *taller = false;
            return false;
        }
        if(e < (*T)->data) //在T的左子树中进行搜索
        {
            if(!InsertAVL(&(*T)->lchild,e,taller))
                return false;
            if(*taller)
            {
                switch((*T)->BF)
                {
                    case 1: //原本左子树比右子树高
                        LeftBalance(T);
                        *taller = false;
                        break;
                    case 0: //原本左右子树等高
                        (*T)->BF = 1;
                        *taller = true;
                        break;
                    case -1: //原本左子树比右子树低
                        (*T)->BF = 0;
                        *taller = false;
                        break;
                }
            }
        }
        else
        {
            if(!InsertAVL(&(*T)->rchild,e,taller))
                return false;
            if(*taller)
            {
                switch((*T)->BF)
                {
                    case 1:
                        (*T)->BF = 0;
                        *taller = false;
                        break;
                    case 0:
                        (*T)->BF = -1;
                        *taller = true;
                        break;
                    case -1:
                        RightBalance(T);
                        *taller = false;
                        break;
                }
            }
        }
    }
    return true;
}

void PreOrderPrint(BiTree T)
{
    if(T==NULL)
        return; 
    cout<<T->data<<" ";
    PreOrderPrint(T->lchild);
    PreOrderPrint(T->rchild);
}

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

    return 0;
}