AVL树实现

AVL树是通过一个一个节点插入创建的；

插入过程：从root向下插，将节点插入子树中，平衡当前树；、

每向下一次就要考虑，有没有出现 如下两种情况
情况1：插入的一侧因为插入的节点导致子树的高度发生变化
情况2：因为插入节点导致当前高发生变化的情况

//二叉树的插入是递归的过程
insertAVL(*treeNd, e, taller)
{
		if()	//当前treeNd为空
		{
			create_node();	//建节点e    遍历到最底层了
			taller = true; //插入新节点后 本来是null现在有元素了从0-1，taller必然是发生了变化，
			return;
		}
		else{
			insertAVL(*treeNd, e, taller);	//节点， 要插元素， 因为插入e，是否使treeNd所指节点为根的树的高发生变化；
			if()	//taller
			{
				left_balance(); 或  right_balance();
				taller = true/false;	//由平衡后*treeNd所指树高度有没有变高决定
			}
		}
}

情况1：插入节点使T本身不平衡

如下 原树：

假如插入节点在A树上, 导致A树高变为 n+2;
则T树高变为n+3;不满足AVL树标准。

那么A树变成n+2后，A的平衡度有2种可能
1：A树左高，调整为如下

最终根的高度还是n+2，就不用向上遍历了（taller = false）
2：A树右高：调整为如下

A和T的bf要看b原来的平衡度；
最终根的高度还是n+2，同样不用向上遍历了（taller = false）

情况2：插入节点使T高发生变化

此时虽然T树不用变，但因为当前树高发生变化
要将T树作为整体向上遍历 // taller=true

taller的值true/false：（）当前层在插入调整后有没有变高

taller在初始化时置为 true；
不断向上层跳，用于在上层判断要不要改树的结构。当当前子树高度不变时taller=false;(一般在平衡后)
如下图：

插入c时，最里层
第一层：向a插；---------------------------改a树的结构,改完后taller变false;
第二层：---------向b插;--------改b的bf;taller = true；
第三层：------------------建c;taller = true；
对第一层插入c前，高为2；
插入c后，经过调整，高还是2，不会对上层起任何影响。

#include<iostream>
#include<stdio.h>
#include<stdlib.h>

using namespace std;
typedef int Status;

constexpr auto LH = +1;
constexpr auto EH = 0;
constexpr auto RH = -1;


//定义平衡二叉树的节点结构(在二叉排序树中加入一个bf来存储平衡因子)
typedef struct BiTNode
{
    int data;
    int bf;
    struct BiTNode* lchild, * rchild;
}BiTNode, *BiTree;




void R_Rotate(BiTree* p);
void L_Rotate(BiTree* p);
void LeftBalance(BiTree *T);
void RightBalance(BiTree* T);
void InOrderTraverse(BiTree *T);
Status InsertAVL(BiTree *T,int e,Status *taller);


//进行二叉平衡树时的右旋操作
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 R;
    R = (*p)->rchild;
    (*p)->rchild = R->lchild;
    R->lchild = (*p);
    *p = R;
}

//构建二叉平衡树时左边太“重”，进行左平衡处理函数
void LeftBalance(BiTree* T)
{
    BiTree L, Lr;
    L = (*T)->lchild;
    switch (L->bf)
    {/*检查T的左子树的平衡度，并做相应的处理*/
        case LH:/*新节点插入在了T的左孩子的左子树上，只要做单左旋处理*/
            (*T)->bf = L->bf = EH;
            R_Rotate(T);
            break;
        case RH:/*新节点插入在了T的左孩子的右子树上，要做双旋处理，
                通过判断T的左孩子的右子树的根节点的bf来决定进行双旋处理后各自的bf值*/
            Lr = L->rchild;
            switch (Lr->bf)
            {
                case LH:
                    (*T)->bf = RH;
                    L->bf = EH;
                    break;
                case EH:
                    (*T)->bf = EH;
                    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, Rl;
    R = (*T)->rchild;
    switch (R->bf)
    {/*检查T的右子树的平衡度，并做相应的处理*/
    case RH:/*新节点插入在了T的右孩子的右子树上，只要做单左旋处理*/
        (*T)->bf = R->bf = EH;
        L_Rotate(T);
        break;
    case LH:/*新节点插入在了T的右孩子的左子树上，要做双旋处理，
            通过判断T的右孩子的左子树的根节点的bf来决定进行双旋处理后各自的bf值*/
        Rl = R->lchild;
        switch (Rl->bf)
        {
        case LH:
            (*T)->bf = EH;
            R->bf = RH;
            break;
        case EH:
            (*T)->bf = R->bf = EH;
            break;
        case RH:
            (*T)->bf = LH;
            R->bf = EH;
            break;
        }
        Rl->bf = EH;
        R_Rotate(&(*T)->rchild);
        L_Rotate(T);
    }
}




//构建二叉平衡树函数

//只再遇到重复值时返回 false
Status InsertAVL(BiTree* T, int e, Status* taller) //  -1, 0, 1 当前插入的tree T是 左重右重还是 平
{
    if (!*T)  //节点不存在  先直接插  再
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        (*T)->data = e;
        (*T)->bf = EH;
        (*T)->lchild = (*T)->rchild = NULL;
        *taller = true;
    }
    else      //找到应该插入的位置
    {
        if (e==(*T)->data)
        {
            *taller = false;
            return false;
        }
        if (e<(*T)->data)  // 向左边插入
        {
            int result = InsertAVL(&(*T)->lchild,e,taller);
            if (!result)
            {
                return false;
            }
            if (*taller)        //insert后变高才需要调整
            {
                switch ((*T)->bf)
                {
                case LH:
                    LeftBalance(T);     
                    *taller = false;
                    break;   //相当于直接return了，由于taller = false;外层也都什么都不做直到root返回;
                case EH:
                    (*T)->bf = LH;
                    *taller = true;  //原平变左高,T树必然变高 还要向上看对父节点有没有影响
                    break;
                case RH:
                    (*T)->bf = EH;
                    *taller = false;
                    break;
                }
            }
        }
        else
        {
            int result = InsertAVL(&(*T)->rchild, e, taller);
            if (!result)
            {
                return false;
            }
            if (*taller)	//insert后变高才需要调整
            {
                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;
}


//二叉树中序遍历递归算法
void InOrderTraverse(BiTree* T)
{
    if (*T==NULL)
    {
        return;
    }
    InOrderTraverse(&(*T)->lchild);
    cout << (*T)->data << " ";
    InOrderTraverse(&(*T)->rchild);
}

int main()
{
    int i;
    int a[10] = {3,2,1,4,5,6,7,10,9,8};
    BiTree T = NULL;
    Status Numtaller = true;//初始化是true或false无所谓，建建节点时都会变true

    for ( i = 0; i < 10; i++)
    {
        InsertAVL(&T, a[i], &Numtaller); 
    }
    //中序遍历输出结果
    InOrderTraverse(&T);
}