完全理解平衡二叉树

非常感谢小甲鱼的讲解与参考下面博客（非常有助于理解程序）

https://blog.csdn.net/deeplan_1994/article/details/82387202

1. 平衡二叉排序树（AVL）【self-Balance Binary Search Tree】

定义：

思路：使用递归算法

这是一个二叉排序树

这不是一棵树二叉排序树，因为3比10小却在10的父节点上

这也不是一颗二叉树，9的左子树的深度是2，右子树的深度是0，相差2，所以不是平衡二叉树

1. 满足二叉排序树要求
2. 满足高度差

节点9是不平衡的关键，

 

旋转图解：

2-0=2>1  右旋

 

#include <QCoreApplication>
#include  <stdio.h>
#include  "stdlib.h"
/*
 @date:2019-5-13
 @author:zhongjilei
 @bried:self-Balance Binary Search Tree
 @platform:Qt---degug调试
*/
#define TRUE 1
#define FALSE 0
#define LH  1 //左子树高
#define EH  0 //左右子树等高
#define RH -1 //右子树高
//==负号进行坐旋转
//==正号进行右旋转
//定义一个二叉树节点
typedef struct BiTNode{

    int data;
    int bf;//平衡因子（就是指该节点的左子树深度-右子树的深度）
    struct BiTNode *lchild,*rchild;

}BiTNode,*BiTree;
/*（Ldepth-Rdepth）>1就进行右旋处理*/
//处理后的P指向新的树根节点，即旋转处理之前的左子树
void R_Rotate(BiTree *p) //以P为根节点
{
    BiTree L;
    L =(*p)->lchild; //L指向P的左子树的根接点
    (*p)->lchild=L->rchild; //L的右子树挂在了P的
    L->rchild=(*p);
    *p=L;//p指向新的接点

}

//左面旋转Ldepth-Rdepth）<-1
void L_Rotate(BiTree *p)
{
    BiTree R;
    R=(*p)->rchild;
    (*p)->rchild=R->lchild;
    R->lchild=(*p);
    *p=R;


}

//左平衡处理代码--处理深度差（Ldepth-Rdepth）<-1的情况,进行左转处理
//符号不一致的时候，比如这时有一个是+1，
//需要先将符号转换为一致再进行处理，将+1转为0或者-1，大家符号相同了在进行一个左旋转
//本算法结束时，指针指向新的根节点
//左子树比右子树高进行左平衡处理
void LeftBalence(BiTree *T)
{
    BiTree L,Lr;
    L=(*T)->lchild;//L指向左子树的根接点
    switch(L->bf) //检查左子树的平衡度，并做平衡处理
    {
    case LH://1 //新节点插在左孩子的左子树上，需要做简单的右旋即可
        (*T)->bf=L->bf=EH; //
        R_Rotate(T);//右转
        break;
    case RH://-1---双旋转
        Lr=L->rchild;
        /*  修改T及其左孩子的平衡因子 */
        switch(Lr->bf)
        {
        case LH:
            (*T)->bf=RH;
            L->bf=EH;
            break;
        case EH:
            (*T)->bf=L->bf=EH;
        case RH:
            (*T)->bf=EH;
            L->bf=LH;
            break;
        }
        Lr->bf=EH;
        L_Rotate(&(*T)->lchild);
        R_Rotate(T);


    }

}
/*  对以指针T所指结点为根的二叉树作右平衡旋转处理， */
/*  本算法结束时，指针T指向新的根结点 */
void RightBalance(BiTree *T)
{
    BiTree R,R1;
    R=(*T)->rchild;
    switch(R->bf)
    {
    case RH:
        (*T)->bf=R->bf=EH;
        L_Rotate(T);
        break;
    case LH: //新节点插入在右孩子的右子树上，就需要进行做双旋处理
        R1=R->lchild;//R1指向右孩子的左树根
        switch(R1->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;

        }
        R1->bf=EH;
        R_Rotate(&(*T)->rchild);
        L_Rotate(T);

    }


}
/*  若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个 */
/*  数据元素为e的新结点，并返回1，否则返回0。若因插入而使二叉排序树 */
/*  失去平衡，则作平衡旋转处理，布尔变量taller反映T长高与否。 */
//创建平衡二叉树
//e：插入的数据
//taller用来判断树长高了没有
int  InsertAVL(BiTree *T,int e, int *taller)
{
    if(!*T) //树空时候
    {
        //找不到就创建一个新的节点
        *T=(BiTree)malloc(sizeof(BiTNode));
        //插入值
        (*T)->data=e;
        (*T)->lchild=(*T)->rchild=NULL;
        (*T)->bf=EH;
        *taller=TRUE;
    }
    //树不是空的时候
    else{
        if(e==(*T)->data)
        {
            //高度就不会增加
            *taller=FALSE;
            return  FALSE;
        }
        if(e<(*T)->data)//小于向左走==加了个左节点
        {
            if(!InsertAVL(&(*T)->lchild,e,taller))//递归调用
            {
                return FALSE;
            }
            if(*taller) //如果长高了，就判断是左长高，还是右长高
            {
                switch((*T)->bf)
                {
                case LH: //左子树高 ---左平衡处理
                    LeftBalence(T);
                    *taller=FALSE;
                    break;
                case EH:
                    (*T)->bf=LH;
                    *taller=TRUE;
                    break;
                case RH:
                    (*T)->bf=EH;
                    *taller=FALSE;

                }

            }
        }
        else //大于往右走，加了个右节点
        {
            if(!InsertAVL(&(*T)->rchild,e,taller))
            {
                return FALSE;
            }
            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;

}
//test
int main(int argc, char *argv[])
{
    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++)
    {
        InsertAVL(&T,a[i],&taller);
    }
    return 0;

}