// AVLTree.cpp : 定义控制台应用程序的入口点。
//
#include"stdafx.h"
#include <iostream>
using namespace std;
template <class T>
struct AVLTreeNode
{
    T data;//平衡二叉树结点值
    int BF;//结点平衡因子
           //平衡二叉树结点左右孩子指针和父结点指针
    AVLTreeNode *pLChild, *pRChild, *pParent;
};
template <class T>
class AVLTree
{
public:
    AVLTree() { pAVLTreeRoot = NULL; };
    virtual ~AVLTree() { DestroyAVLTree(pAVLTreeRoot); };
    void InsertAVLTreeNode(int vAVLTNValue);//AVL 树插入关键字函数
    int InsertAVLTreeNode(AVLTreeNode<T> *&vAVLTreeRoot, int vBTNValue, bool &vHeight);//重载 AVL 树插入关键字函数
    void DeleteAVLTreeNode(int vAVLTNValue);//AVL 树删除关键字函数
    int DeleteAVLTreeNode(AVLTreeNode<T> *&vPAVLTreeNode, int vAVLTNValue);//重载 AVL 树删除关键字函数
    void DestroyAVLTree(AVLTreeNode<T> *&vPAVLTreeNode);//销毁 AVL 树
    void LL_Rotate(AVLTreeNode<T> *&vAVLTreeNode);//LL 型
    void LR_Rotate(AVLTreeNode<T> *&vAVLTreeNode);//LR 型
    void RR_Rotate(AVLTreeNode<T> *&vAVLTreeNode);//RR 型
    void RL_Rotate(AVLTreeNode<T> *&vAVLTreeNode);//RL 型
    int LeftBalance(AVLTreeNode<T> *&vAVLTreeNode);//左平衡处理函数
    int RightBalance(AVLTreeNode<T> *&vAVLTreeNode);//右平衡处理函数
    int FindSuccessor(AVLTreeNode<T> *&vPAVLTreeNode_P, AVLTreeNode<T> *&vPAVLTreeNode_Q);//查找被删除关键字的替代结点函数
    void PrintAVLTree(AVLTreeNode<T>* vAVLTreeNode);//重载中序输出 AVL 树
    void PrintAVLTree();//中序输出 AVL 树
    void LeftHorzShow(AVLTreeNode<T>* vAVLTreeNode, int nLayer);//重载横向输出 AVL 树
    void LeftHorzShow();//横向输出 AVL 树
private:
    AVLTreeNode<T>* pAVLTreeRoot;//平衡二叉树根结点指针
    int searchValue;//AVL 树待查找值
    typedef enum { RH = -1, EH = 0, LH = 1 };//AVL 树常量
};
template<class T>
void AVLTree<T>::DestroyAVLTree(AVLTreeNode<T> *&vPAVLTreeNode)
{
    if (vPAVLTreeNode != NULL) {
        DestroyAVLTree(vPAVLTreeNode->pLChild);
        DestroyAVLTree(vPAVLTreeNode->pRChild);
        delete vPAVLTreeNode;
    }
}
template<class T>
void AVLTree<T>::InsertAVLTreeNode(int vAVLTNValue)
{
    bool tHeight;
    InsertAVLTreeNode(pAVLTreeRoot, vAVLTNValue, tHeight);
}
template<class T>
int AVLTree<T>::InsertAVLTreeNode(AVLTreeNode<T> *&vAVLTreeRoot, int vBTNValue,
    bool &vHeight)
{
    if (!vAVLTreeRoot)
    {//如果为空树则创建一个结点
        vAVLTreeRoot = new AVLTreeNode<T>();
        vAVLTreeRoot->data = vBTNValue;
        vAVLTreeRoot->pLChild = NULL;
        vAVLTreeRoot->pRChild = NULL;
        vAVLTreeRoot->pParent = NULL;
        vAVLTreeRoot->BF = 0;
        vHeight = true;
        return 1;
    }
    else
    {
        if (vAVLTreeRoot->data == vBTNValue)
        {
            vHeight = false; return 0;
        }//结点已存在,不应再插入
        if (vAVLTreeRoot->data > vBTNValue)
        {//应插入左子树
            if (!InsertAVLTreeNode(vAVLTreeRoot->pLChild, vBTNValue, vHeight))
                return 0;
            if (vHeight)
            {//如果左子树变高,依据 T 的平衡因子操作
                switch (vAVLTreeRoot->BF)
                {
                case LH://T 的平衡因子变为 2,需作左平衡处理
                    LeftBalance(vAVLTreeRoot);
                    vHeight = false;
                    break;
                case EH:
                    vAVLTreeRoot->BF = 1;
                    vHeight = true;
                    break;
                case RH:
                    vHeight = false;
                    vAVLTreeRoot->BF = 0;
                    break;
                }//switch
            }//if
        }//if
        else
        {//插在右子树
            if (!InsertAVLTreeNode(vAVLTreeRoot->pRChild, vBTNValue, vHeight))
                return 0;
            if (vHeight)
            {
                switch (vAVLTreeRoot->BF)
                {//如果右子树变高
                case LH:
                    vAVLTreeRoot->BF = 0;
                    vHeight = false;
                    break;
                case EH:
                    vAVLTreeRoot->BF = -1;
                    vHeight = true;
                    break;
                case RH://平衡因子变成-2,作右平衡处理
                    RightBalance(vAVLTreeRoot);
                    vHeight = false;
                    break;
                }//switch
            }//if
        }//else
        return 1;
    }//else
    return 1;
}
template<class T>
int AVLTree<T>::LeftBalance(AVLTreeNode<T>*&vAVLTreeNode)
{
    if (vAVLTreeNode->pLChild&&vAVLTreeNode->pLChild->BF == LH)
        LL_Rotate(vAVLTreeNode);
    else if (vAVLTreeNode->pLChild&&vAVLTreeNode->pLChild->BF == RH)
        LR_Rotate(vAVLTreeNode);
    return 2;
}
template<class T>
int AVLTree<T>::RightBalance(AVLTreeNode<T>*&vAVLTreeNode)
{
    if (vAVLTreeNode->pRChild&&vAVLTreeNode->pRChild->BF == LH)
        RL_Rotate(vAVLTreeNode);
    else if (vAVLTreeNode->pRChild&&vAVLTreeNode->pRChild->BF == RH)
        RR_Rotate(vAVLTreeNode);
    return 2;
}

template<class T>
void AVLTree<T>::LL_Rotate(AVLTreeNode<T> *&vAVLTreeNode)
{
    AVLTreeNode<T>* tCurAVLTreeNode = vAVLTreeNode->pLChild;
    vAVLTreeNode->pLChild = tCurAVLTreeNode->pRChild;
    tCurAVLTreeNode->pRChild = vAVLTreeNode;
    switch (tCurAVLTreeNode->BF) {
    case LH:
        vAVLTreeNode->BF = EH;
        tCurAVLTreeNode->BF = EH;
        break;
    case EH:
        vAVLTreeNode->BF = LH;
        tCurAVLTreeNode->BF = RH;
        break;
    }
    vAVLTreeNode = tCurAVLTreeNode;
}
template<class T>
void AVLTree<T>::RR_Rotate(AVLTreeNode<T> *&vAVLTreeNode)
{
    //实现 RR 旋转
    AVLTreeNode<T>* tCurAVLTreeNode = vAVLTreeNode->pRChild;
    vAVLTreeNode->pRChild = tCurAVLTreeNode->pLChild;
    tCurAVLTreeNode->pLChild = vAVLTreeNode;
    switch (tCurAVLTreeNode->BF)
    {
    case RH:
        vAVLTreeNode->BF = EH;
        tCurAVLTreeNode->BF = EH;
        break;
    case EH:
        vAVLTreeNode->BF = RH;
        tCurAVLTreeNode->BF = LH;
        break;
    }
    vAVLTreeNode = tCurAVLTreeNode;

}
template<class T>
void AVLTree<T>::LR_Rotate(AVLTreeNode<T> *&vAVLTreeNode)
{
    //实现 LR 旋转
    AVLTreeNode<T>*tAVLTreeNode_P = vAVLTreeNode->pLChild;
    AVLTreeNode<T>*tAVLTreeNode_Q = tAVLTreeNode_P->pRChild;
    tAVLTreeNode_P->pRChild = tAVLTreeNode_Q->pLChild;
    tAVLTreeNode_Q->pLChild = tAVLTreeNode_P;
    vAVLTreeNode->pLChild = tAVLTreeNode_Q->pRChild;
    tAVLTreeNode_Q->pLChild = vAVLTreeNode;
    switch (tAVLTreeNode_Q->BF)
    {
    case RH:
        tAVLTreeNode_P->BF = LH;
        vAVLTreeNode->BF = EH;
        break;
    case EH:
        tAVLTreeNode_P->BF = EH;
        vAVLTreeNode->BF = EH;
        break;
    case LH:
        tAVLTreeNode_P->BF = EH;
        vAVLTreeNode->BF = RH;
        break;
    }
    tAVLTreeNode_Q->BF = EH;
    vAVLTreeNode = tAVLTreeNode_Q;

}
template<class T>
void AVLTree<T>::RL_Rotate(AVLTreeNode<T> *&vAVLTreeNode)
{
    AVLTreeNode<T>* tAVLTreeNode_P = vAVLTreeNode->pRChild;
    AVLTreeNode<T>* tAVLTreeNode_Q = tAVLTreeNode_P->pLChild;
    tAVLTreeNode_P->pLChild = tAVLTreeNode_Q->pRChild;
    tAVLTreeNode_Q->pRChild = tAVLTreeNode_P;
    vAVLTreeNode->pRChild = tAVLTreeNode_Q->pLChild;
    tAVLTreeNode_Q->pLChild = vAVLTreeNode;
    switch (tAVLTreeNode_Q->BF) {
    case LH:
        tAVLTreeNode_P->BF = RH;
        vAVLTreeNode->BF = EH;
        break;
    case EH:
        tAVLTreeNode_P->BF = EH;
        vAVLTreeNode->BF = EH;
        break;
    case RH:
        tAVLTreeNode_P->BF = EH;
        vAVLTreeNode->BF = LH;
        break;
    }
    tAVLTreeNode_Q->BF = EH;
    vAVLTreeNode = tAVLTreeNode_Q;
}
template<class T>
void AVLTree<T>::DeleteAVLTreeNode(int vAVLTNValue)
{
    DeleteAVLTreeNode(pAVLTreeRoot, vAVLTNValue);
}
template<class T>
int AVLTree<T>::DeleteAVLTreeNode(AVLTreeNode<T> *&vPAVLTreeRoot,
    int vAVLTNValue)
{
    int tStatus;
    if (vPAVLTreeRoot == NULL) return 0;
    if (vPAVLTreeRoot->data > vAVLTNValue) {
        tStatus = DeleteAVLTreeNode(vPAVLTreeRoot->pLChild, vAVLTNValue);
        if (tStatus < 2) return tStatus;
        switch (vPAVLTreeRoot->BF) {
        case LH:
            vPAVLTreeRoot->BF = 0;
            return 2;
        case EH:
            vPAVLTreeRoot->BF = -1;
            return 1;
        case RH:
            return RightBalance(vPAVLTreeRoot);
        }
    }
    if (vPAVLTreeRoot->data < vAVLTNValue) {
        tStatus = DeleteAVLTreeNode(vPAVLTreeRoot->pRChild, vAVLTNValue);
        if (tStatus < 2) return tStatus;
        switch (vPAVLTreeRoot->BF) {
        case RH:
            vPAVLTreeRoot->BF = 0;
            return 2;
        case EH:
            vPAVLTreeRoot->BF = 1;
            return 1;
        case LH:
            return LeftBalance(vPAVLTreeRoot);
        }
    }
    else {
        AVLTreeNode<T> *tCurAVLTreeNode = vPAVLTreeRoot;
        if (vPAVLTreeRoot->pLChild == NULL) {
            vPAVLTreeRoot = vPAVLTreeRoot->pRChild;
            tStatus = 2;
        }
        else
            if (vPAVLTreeRoot->pRChild == NULL) {
                vPAVLTreeRoot = vPAVLTreeRoot->pLChild;
                tStatus = 2;
            }
            else {
                tStatus = FindSuccessor(tCurAVLTreeNode,
                    vPAVLTreeRoot->pRChild);
                if (tStatus < 2) return tStatus;
                switch (vPAVLTreeRoot->BF) {
                case RH:
                    vPAVLTreeRoot->BF = 0;
                    return 2;
                case EH:
                    vPAVLTreeRoot->BF = 1;
                    return 1;
                case LH:
                    return LeftBalance(vPAVLTreeRoot);
                }
            }
            delete tCurAVLTreeNode;
            return tStatus;
    }
    return 0;
}
template<class T>
int AVLTree<T>::FindSuccessor(AVLTreeNode<T> *&vPAVLTreeNode_P,
    AVLTreeNode<T> *&vPAVLTreeNode_Q)
{
    int tStatus;
    if (vPAVLTreeNode_Q->pLChild) {
        tStatus = FindSuccessor(vPAVLTreeNode_P, vPAVLTreeNode_Q->pLChild);
        if (tStatus < 2) return tStatus;
        switch (vPAVLTreeNode_Q->BF) {
        case LH:
            vPAVLTreeNode_Q->BF = 0;
            return 2;
        case EH:
            vPAVLTreeNode_Q->BF = -1;
            return 1;
        case RH:
            RightBalance(vPAVLTreeNode_P);
        }
    }
    else {
        vPAVLTreeNode_P->data = vPAVLTreeNode_Q->data;
        vPAVLTreeNode_P = vPAVLTreeNode_Q;
        vPAVLTreeNode_Q = vPAVLTreeNode_Q->pRChild;
        return 2;
    }
    return 0;
}
//中序遍历函数
template<class T>
void AVLTree<T>::PrintAVLTree(AVLTreeNode<T>* vAVLTreeNode)
{
    if (vAVLTreeNode == NULL) return;
    PrintAVLTree(vAVLTreeNode->pLChild);//先遍历左子树
    cout << vAVLTreeNode->data << " ";//输出根节点
    PrintAVLTree(vAVLTreeNode->pRChild);//再遍历右子树
}
//中序遍历接口
template<class T>
void AVLTree<T>::PrintAVLTree()
{
    PrintAVLTree(pAVLTreeRoot);
}
template <class T>
void AVLTree<T>::LeftHorzShow()
{
    LeftHorzShow(pAVLTreeRoot, 0);
}
template <class T>
void AVLTree<T>::LeftHorzShow(AVLTreeNode<T>* vAVLTreeNode, int nLayer)
{
    if (vAVLTreeNode == NULL)
        return;
    else
    {
        LeftHorzShow(vAVLTreeNode->pRChild, nLayer + 1);
        for (int i = 0; i < nLayer; i++)
            cout << " ";
        cout << vAVLTreeNode->data << endl;
        LeftHorzShow(vAVLTreeNode->pLChild, nLayer + 1);
    }
}
void main()
{
    AVLTree<int> tempAVLTree;
    int tempDataSet[10] = { 1,2,3,4,5,6,7,8,9,10 }; for (int i = 0; i < 10; i++) { cout << "插入结点:" << tempDataSet[i] << endl; tempAVLTree.InsertAVLTreeNode(tempDataSet[i]); cout << "横向输出 AVL 树:" << endl; tempAVLTree.LeftHorzShow(); cout << endl; } cout << "删除结点:" << tempDataSet[5] << endl; tempAVLTree.DeleteAVLTreeNode(tempDataSet[5]); tempAVLTree.LeftHorzShow(); cout << endl; system("pause"); }