AVL树的实现

AVL树：

AVL树也成为平衡二叉树，它是这样定义的：

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

1、它的左右子树都是AVL树

2、左子树和右子树高度之差(简称平衡因子)的绝对值不超过1(-1、0、1)

AVL树的插入：

在插入节点后会造成父节点的平衡因子发生改变，需要从下往上更新平衡因子，若某一节点的平衡因子的绝对值大于1，说明以这个结点为根的树已经不平衡，此时就要去通过旋转来让数重新达到平衡状态。

旋转规则：

左单旋：在较高右子树的右侧插入了结点

右单旋：在较高左子树的左侧插入了结点

先左后右：在较高左子树的右侧插入了结点

先右后左：在较高右子树的左侧插入了结点

对于较高子树的理解：

较高子树就是不平衡树中的高度较大的子树。

下面是通过右左旋转达到平衡和通过左旋转达到平衡的例子：

下面是通过左右旋转达到平衡和通过右旋转达到平衡的例子：

通过上面的例子我们可以得到以下结论：

当一棵树不平衡时，如果这棵树根节点和其平衡因子不为0的结点的平衡因子符号相同则通过一次旋转即可重新平衡，否则就需要两次旋转。

根为2，子节点为1，通过左旋转即可平衡

根为2，子节点为-1，通过右左旋转才能平衡

根为-2，子节点为1，通过左右旋转才能平衡

根为-2，子节点为-1，通过右旋转即可平衡

注意：在旋转完成之后记得要把平衡因子修改为适当的值，可以通过画出图片做以分析，得到规律

代码：

#include<iostream>
#include<windows.h>

using namespace std;

template<typename K, typename V>
struct AVLTreeNode
{
    AVLTreeNode()
    {}
    AVLTreeNode(const K& _key, const V& _value = V())
        : key(_key)
        , value(_value)
        , bf(0)
        , pLeft(NULL)
        , pRight(NULL)
        , pParent(NULL)
    {}
    K key;
    V value;
    int bf;
    AVLTreeNode *pLeft;
    AVLTreeNode *pRight;
    AVLTreeNode *pParent;
};

template<typename K, typename V>
class AVLTree
{
    typedef AVLTreeNode<K, V> Node;
public:
    AVLTree()
        :pRoot(NULL)
    {}
    bool Inserter(const K& _key)
    {
        //
        Node* pCur = pRoot;
        Node* parent = NULL;
        if (NULL == pRoot)
        {
            pRoot = new Node(_key);
            return true;
        }
        else
        {
            //找到插入位置
            while (pCur)
            {
                if (pCur->key < _key)
                {
                    parent = pCur;
                    pCur = pCur->pRight;
                }
                else if (pCur->key > _key)
                {
                    parent = pCur;
                    pCur = pCur->pLeft;
                }
                else
                    return false;
            }
            //插入结点
            pCur = new Node(_key);
            if (parent->key > _key)
            {
                parent->pLeft = pCur;
            }
            else
                parent->pRight = pCur;
            pCur->pParent = parent;
        }
        //自下向上更新平衡因子
        while (parent)
        {
            //更新当前结点父节点的平衡因子
            if (parent->pLeft == pCur)
            {
                parent->bf--;
            }
            else
            {
                parent->bf++;
            }
            //如果其父节点的平衡因子为0，则说明达到平衡
            if (0 == parent->bf)
            {
                break;
            }
            //如果是1，则继续向上更新
            else if (1 == parent->bf || -1 == parent->bf)
            {
                pCur = parent;
                parent = pCur->pParent;
            }
            //不是1，就可能是+-2，此时子树不平衡需要调整
            //一旦parent的因子绝对值==2，说明其需要调整，此时较高子树是相对于它而言的
            else
            {
                //右子树高
                if (parent->bf == 2)
                {

                    //右子树的右侧高
                    if (pCur->bf == 1)
                    {
                        //左旋转
                        RotateLeft(parent);
                        break;
                    }
                    //右子树的左侧高
                    else
                    {
                        //右左旋转
                        RotateRL(pCur);
                        break;
                    }
                }
                //左子树高
                else
                {
                    //左子树的左侧高
                    if (pCur->bf == -1)
                    {
                        //右旋
                        RotateRight(parent);
                        break;
                    }
                    //左子树的右侧高
                    else
                    {
                        //左右旋转
                        RotateLR(pCur);
                        break;
                    }
                }
            }
        }
        return true;
    }
    bool IsBalanceTree()//判断树是不是AVL树
    {
        return _IsBalanceTree(pRoot);
    }
    int Hight()//求书的高度
    {
        return _Hight(pRoot);
    }
    void InOrder()
    {
        _InOrder(pRoot);
        cout << endl;
    }
private:
    bool _IsBalanceTree(Node *pRoot)
    {
        if (NULL == pRoot)
            return true;
        int left = _Hight(pRoot->pLeft);
        int right = _Hight(pRoot->pRight);

        if (pRoot->bf != (right - left) || std::abs(pRoot->bf) > 1)
            return false;
        return _IsBalanceTree(pRoot->pLeft) && _IsBalanceTree(pRoot->pRight);
    }
    void _InOrder(Node* pRoot)
    {
        if (NULL == pRoot)
            return;
        _InOrder(pRoot->pLeft);
        cout << pRoot->key << " ";
        _InOrder(pRoot->pRight);
    }
    int _Hight(Node* pRoot)
    {
        if (NULL == pRoot)
            return 0;
        if (NULL == pRoot->pLeft && NULL == pRoot->pRight)
            return 1;
        int left = _Hight(pRoot->pLeft)+1;
        int right = _Hight(pRoot->pRight)+1;
        return left > right ? left : right;
    }
    //左旋---->就是用父节点的右孩子去替换父节点，将父节点连接在其右孩子的左侧
    void RotateLeft(Node *parent)
    {
        Node* pParent = parent->pParent;
        Node* pSubR = parent->pRight;
        Node* pSubRL = pSubR->pLeft;

        //父节点的右链接右孩子的左结点
        parent->pRight = pSubRL;
        //右孩子成为父节点的父节点
        parent->pParent = pSubR;

        //右孩子的左结点存在，更新其父节点
        if (pSubRL)
            pSubRL->pParent = parent;
        //更新右孩子的父节点和左结点
        pSubR->pParent = pParent;
        pSubR->pLeft = parent;

        //如果pParent存在
        if (pParent)
        {
            //说明这是一颗子树
            //将右节点连接在pParent的左或者右
            if (pParent->pLeft == parent)
            {
                pParent->pLeft = pSubR;
            }
            else
            {
                pParent->pRight = pSubR;
            }
        }
        //pParent不存在，说明父节点是树根
        else//这是树根将变为右节点
            pRoot = pSubR;
        //将其平衡因子置0
        parent->bf = pSubR->bf = 0;
    }
    //右旋
    void RotateRight(Node* parent)
    {
        Node* pParent = parent->pParent;
        Node* pSubL = parent->pLeft;
        Node* pSubLR = pSubL->pRight;

        parent->pLeft = pSubLR;
        parent->pParent = pSubL;

        if (pSubLR)
            pSubLR->pParent = parent;

        pSubL->pParent = pParent;
        pSubL->pRight = parent;
        if (pParent)
        {
            if (pParent->pLeft == parent)
                pParent->pLeft = pSubL;
            else
                pParent->pRight = pSubL;
        }
        else
        {
            pRoot = pSubL;
        }
        parent->bf = pSubL->bf = 0;
    }
    //左右旋转
    void RotateLR(Node* parent)
    {
        //判断其右孩子的平衡因子
        int bf = parent->pRight->bf;
        //parent左旋，parent下降其父节点成为其父节点的父节点
        RotateLeft(parent);
        //parent之前的父节点右旋
        RotateRight(parent->pParent->pParent);

        if (bf == -1)
        {//说明parent接受了其右孩子的左孩子，
            parent->pParent->pRight->bf = 1;
        }
        else if (1 == bf)
        {
            //说明parent的父节点，接受了其右孩子的右孩子
            parent->bf = -1;
        }
    }
    //右左旋转
    void RotateRL(Node* parent)
    {
        int bf = parent->pLeft->bf;
        RotateRight(parent);
        RotateLeft(parent->pParent->pParent);
        if (1 == bf)
        {
            parent->pParent->pLeft->bf = -1;
        }
        else if (-1 == bf)
        {
            parent->bf = 1;
        }
    }
protected:
    Node* pRoot;
};