平衡二叉树-代码详解

平衡二叉树是一种特殊的搜索二叉树，普通的搜索二叉树没有限制左右子树的高度关系，当搜索二叉树时斜树时查找效率了低，为了解决这种极端问题就考虑左右子树的高度关系，平衡二叉树就是限制左右子树高度差不超过1。从而来避免这种问题同时提高搜索效率。

代码如下：

#define LH 1
#define EH 0
#define RH -1

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

void R_Rotate(BiTree*p)
{
    BiTree L;
    L=(*p)->lchild;
    (*p)->lchild=L->rchild;
    L->rchild=(*p);
    (*p)=L;
}
void L_Rotate(BiTree*p)
{
    BiTree L;
    L=(*p)->rchild;
    (*p)->rchild=L->rchild;
    L->lchild=(*p);
    (*p)=L;
}

void LeftBalance(BiTree *T)         //此处T为不平衡点
{
    BiTree L,Lr;                           //L为毗邻T的左孩子，Lr为毗邻L的右孩子
    L=(*T)->lchild;
    switch(L->bf)                            
    {
        case LH:
            (*T)->bf=L->bf=EH;             //右旋处理T节点之后的最终结果
            R_Rotate(T);
            break;
        case RH:
            Lr=L->rchild;
            switch(Lr->bf)
            {
                case LH:
                    (*T)->bf=RH;          //先左旋处理L、后右旋处理T节点之后的最终结果
                    L->bf=EH;
                    break;
                case EH:
                    (*T)->bf=L->bf=EH;    //先左旋处理L、后右旋处理T节点之后的最终结果
                    break;
                case RH:
                    (*T)->bf=EH;          //先左旋处理L、后右旋处理T节点之后的最终结果
                    L->bf=LH;
                    break;
            }
                Lr->bf=EH;                   



           
        /*思路是上上面代码是对节点平衡状态做出修改，下面是进行的双旋转操作。简单来说就
是先写结果在写操作。*/
                L_Rotate(&(*T)->lchild);         
                R_Rotate(T);   
    }
    }                           

void RightBalance(BiTree *T)        
{
    BiTree L,Lr;                              
    L=(*T)->rchild;
    switch(L->bf)                       
    {
        case RH:
            (*T)->bf=L->bf=EH;            
            L_Rotate(T);
            break;
        case LH:
            Lr=L->lchild;
            switch(Lr->bf)
            {
                case RH:
                    (*T)->bf=LH;            
                    L->bf=EH;
                    break;
                case EH:
                    (*T)->bf=L->bf=EH;   
                    break;
                case LH:
                    (*T)->bf=EH;               
                    L->bf=RH;
                    break;
            }
            Lr->bf=EH;                        
            break;
    }
    R_Rotate(&(*T)->rchild);         
    L_Rotate(T);                              
}  




int InsertAVL(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=TRUE;              //新增结点T，通过这种方式判断是否有节点生成比较简单
    }
    else
    {
        if(e==(*T)->data)
        {
            *taller=FALSE;
            return FALSE;
        }
        else if(e<(*T)->data)
        {
            if(!InsertAVL(&(*T)->lchild,e,taller))  //这个递归为了找到插入新节点位置。
               {
                   return FALSE;
               }
            if(*taller)                //每次插入一个结点后修改结点的bf值及调整平衡
                {
                    switch((*T)->bf)
                    {

                        /*当前加入的节点是在该节点的左子树中，判断该节点的状态，case LH指
的是未插入时节点的状态，：后面的内容是在更新节点状态值。*/
                         case LH:
                             LeftBalance(T);
                             break;
                         case EH:
                            (*T)->bf=LH;
                            break;
                         case RH:
                            (*T)->bf=EH;
                            break;
                    }
                    *taller=FALSE;       //插入的结点处理完毕后*taller初始化
                    }
                }
         else
         {
              if(!InsertAVL(&(*T)->rchild,e,taller))
               {
                   return FALSE;
               }
              if(*taller)            
                {
                    switch((*T)->bf)
                    {
                         case RH:
                             RightBalance(T);
                             break;
                         case EH:
                            (*T)->bf=RH;
                            break;
                         case LH:
                            (*T)->bf=EH;
                            break;
                    }
                    *taller=FALSE;       //插入的结点处理完毕后*taller初始化
                }
         }
        }
 }

 有几个问题挺重要：

        1 关于检测更新节点状态的部分，在找到插入节点合适的位置的时候使用了递归，因此节点状态更新也是递归的这一点很重要。

        2 两种旋转情况准确说四种吧：LL，RR，LR，RL。当LL，RR时进行单旋转即可，当LR，RL时进行双旋转实际上，先把LR变成LL在进行旋转，给俩图俩情况：

       双旋转：当9作为新节点插入时，4，6，7，均为R，而10未L，这是需要10右旋转，9替代原来的10，此时9未R，这时对7进行左旋即可。

        

 单旋转：当插入6时破坏平衡，2，4，5，6均为R。只需要对2进行左旋即可这时4作为根节点左孩子是2，右孩子是5，3剥离作为2的右孩子。

 具体左旋右旋代码很简单，注意像第二种情况中节点4存在左孩子，这时把3作为2的右孩子，和4没有左孩子操作是一样的，想象成4的左孩子存在只不过是null。

        3 下面这段代码中switch（L->bf）中只有两种情况为什么没有EH，就是为什么L->bf =EH不存在，大家可以试一下L-bf=EH存在的情况自己画出来。

void RightBalance(BiTree *T)        
{
    BiTree L,Lr;                              
    L=(*T)->rchild;
    switch(L->bf)                       
    {
        case RH:
            (*T)->bf=L->bf=EH;            
            L_Rotate(T);
            break;
        case LH:
            Lr=L->lchild;
            switch(Lr->bf)
            {
                case RH:
                    (*T)->bf=LH;            
                    L->bf=EH;
                    break;
                case EH:
                    (*T)->bf=L->bf=EH;   
                    break;
                case LH:
                    (*T)->bf=EH;               
                    L->bf=RH;
                    break;
            }
            Lr->bf=EH;                        
            break;
    }
    R_Rotate(&(*T)->rchild);         
    L_Rotate(T);                              
}

 这时原来的树，下面是新节点1插入的树。

 

这种情况3是一个不平衡点，3的右子树函数中时L，L时平衡的看似没什么问题但是问大家，加入1是新节点，请问1是怎么插入在一个原来就不平衡的棵树上的。这显然是不可能的所以L->bf不可能为EH

        4 最后一个就是在进行双旋转前的状态修改问题，为什么switch后还需要把Lr->bf设置为EH，本来双旋转是存在两种结果的但是为什么这里必须要把Lr->设置为EH。

          注意双旋转操作在L会有两种状态一种是L->bf=EH另一种是L->bf=LH;但是这个修改是递归修改的因为下面的InsertAVL函数中通过递归创建的节点。每次创建节点都会进行先前节点状态检查然后修改状态变为当前节点的状态。最终被修改好的节点都会以Lr为根节点并且最终会平衡（注意是最终）之所以把Lr->bf设置为EH就是因为如果递归还没结束这个不平衡的子树会影响节点状态导致最终树不平衡。这里说的树是被修改的，例如从根节点到最后一个不平衡节点可能把最后一个不平衡点解决掉整棵树就是符合平衡二叉树，但是根节点未必bf等于EH.我说的是内个被修改的节点bf等于EH。