前言：

什么叫做AVL树？

    AVL树的定义：

1、AVL的左右子树高度之差的绝对值不超过1；

2、树中的左右子树都为AVL树

3、平衡因子只能是（-1、0、1）

    AVL树的效率

AVL树的总共节点为N个，他的高度能搞保持在logN,插入、删除、查找等操作的时间复杂度也是logN。

    AVL树的实现：

1、AVL树的插入：

思路分析：1> 既然是插入就需要先找到插入的位置，使用while循环遍历找到插入位置

                   2> 找到插入位置以后直接插入，然后向上遍历修改父节点的平衡因子，当修改完以后的平衡因子有等于2或者-2的挑出来，进行树的旋转，并且调整平衡因子，使满足AVL树的定义。

                   3> 旋转过程中需要考虑是左旋转、右旋转、左右旋转、还是右左旋转。左右旋转简单，直接调用自己编写的左右旋转函数即可，只要传过来的节点记得加上引用就行了，这样能够直接连接到旋转后的子树。重点在于左右和右左旋转，我们是否能直接调用左旋转函数和右旋转函数各一次？答案是否定的，因为在旋转的过程中，不是在插入的那个位置进行旋转，而是在中间进行旋转，这是后父亲节点和祖父节点的平衡因子BF就需要自己手动来定义了。以右左旋转来分析：

如果当前节点的平衡因子为-1，那么他的parent应该为1，pparent应该为0；

如果当前节点的平衡因子为1，那么他的parent应该为0，pparent应该为-1；

如果当前节点的平衡因子为0，那么他的parent应该为0，pparent应该为0；

具体自己下去画个图，在插入节点的位置（cur）下面加一个左节点或者右节点，然后分析。

#ifndef __BALANCETREE_H__
#define __BALANCETREE_H__

template<class K,class V>
struct BLNode
{
    K _key;
    V _value;
    BLNode<K, V>* _left;
    BLNode<K, V>* _right;
    BLNode<K, V>* _parent;
    int _bf;

    BLNode(const K& key, const V& value)
        :_key(key)
        , _value(value)
        , _parent(NULL)
        , _left(NULL)
        , _right(NULL)
        , _bf(0)
    {}

};

template<class K,class V>
class BalanceTree
{
    typedef BLNode<K, V> Node;

public:
    BalanceTree()
        :_root(NULL)
    {}

    bool Insert(const K& key, const V& value)
    {
        //先查找需要插入的位置
        if (_root == NULL)
        {
            _root = new Node(key, value);
            return true;
        }

        Node* parent = NULL;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else
            {
                return false;
            }
        }

        //找到插入位置以后,确定平衡因子
        Node* ppNode = parent->_parent;
        

        if (parent->_key > key)//找到插入位置以后判断是在父节点的左边还是右边，插入以后先调整平衡因子，向上遍历，如果本来是-1或者1插入以后为0就不用调整了，因为上一层看到的还是这一层的高度没有变
        {
            cur = new Node(key, value);
            parent->_left = cur;
            cur->_parent = parent;
            parent->_bf--;
            while (parent)
            {
                if ((parent->_bf == -1 ||parent->_bf ==1)&& parent->_parent != NULL)
                {
                    if (parent->_parent->_key >parent->_key)
                        parent->_parent->_bf--;
                    else if (parent->_parent->_key < parent->_key)
                        parent->_parent->_bf++;
                    if (parent->_parent->_bf == 2 || parent->_parent->_bf == -2)
                        break;
                    cur = parent;
                    parent = parent->_parent;
                }
                else
                    break;
            }
            
        }

        else if (parent->_key < key)
        {
            cur = new Node(key, value);
            parent->_right = cur;
            cur->_parent = parent;
            parent->_bf++;
            while (parent)
            {
                if ((parent->_bf == 1 ||parent->_bf == -1)&& parent->_parent != NULL)
                {
                    if (parent->_parent->_key >parent->_key)
                        parent->_parent->_bf--;
                    else if (parent->_parent->_key < parent->_key)
                        parent->_parent->_bf++;
                    if (parent->_parent->_bf == 2 || parent->_parent->_bf == -2)
                        break;
                    cur = parent;
                    parent = parent->_parent;
                }
                else
                    break;
            }
        }

        //根据平衡因子的变动，开始调整当前的树，因为刚刚是平衡因子不符合的时候跳出来的
        ppNode = parent->_parent;
        Node* pppNode = NULL;
        if (ppNode!=NULL)
            pppNode = ppNode->_parent;
        if (ppNode && (ppNode->_bf == 2 || ppNode->_bf == -2))
        {
            //左旋
            if (parent == ppNode->_right && parent->_right == cur)
            {
                RotateL(ppNode);
            }

            //右旋
            else if (ppNode->_left == parent && parent->_left == cur)
            {
                RotateR(ppNode);
            }

            //左右双旋
            else if (ppNode->_left == parent &&parent->_right == cur)
            {
                int bf = cur->_bf;
                Node* pNode = ppNode;
                Node* pLeftNode = parent;
                RotateL(parent);//先左旋，再链接
                ppNode->_left = parent;
                RotateR(ppNode);

                if (bf == 0)
                {
                    pNode->_bf = 0;
                    pLeftNode->_bf = 0;
                }
                else if (bf == -1)
                {
                    pNode->_bf = 1;
                    pLeftNode->_bf = 0;
                }
                else if (bf == 1)
                {
                    pNode->_bf = 0;
                    pLeftNode->_bf = -1;
                }
            }

            //右左双旋
            else if (ppNode->_right == parent &&parent->_left == cur)
            {
                int bf = cur->_bf;
                Node* pNode = ppNode;
                Node* pRightNode = parent;
                RotateR(parent);
                ppNode->_right = parent;
                RotateL(ppNode);

                if (bf == 0)
                {
                    pNode->_bf = 0;
                    pRightNode->_bf = 0;
                }
                else if (bf == -1)
                {
                    pNode->_bf = 0;
                    pRightNode->_bf = 1;
                }
                else if (bf == 1)
                {
                    pNode->_bf = -1;
                    pRightNode->_bf = 0;
                }
            }

            if (pppNode == NULL)
            {
                _root = ppNode;
            }
            else
            {
                if (pppNode->_key > ppNode->_key)
                    pppNode->_left = ppNode;
                else if (pppNode->_key < ppNode->_key)
                    pppNode->_right = ppNode;
            }

        }
    }


    size_t Height()
    {
        return _Height(_root);
    }
    
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

protected:
    size_t _Height(Node* root)
    {
        if (root == NULL)
            return 0;

        return _Height(root->_left) > _Height(root->_right) ? _Height(root->_left) + 1 : _Height(root->_right) + 1;
    }
    void _InOrder(Node* root)
    {
        if (root == NULL)
            return;

        _InOrder(root->_left);
        cout << root->_key << " ";
        _InOrder(root->_right);
    }

    void rotateL(Node*& parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        subR->_parent = parent->_parent;
        subR->_left = parent;
        parent->_parent = subR;

        parent->_right = subRL;
        if (subRL != NULL)
            subRL->_parent = parent;

        parent->_bf = 0;
        subR->_bf = 0;

        parent = subR;
    }

    void RotateL(Node*& parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        if (subRL != NULL)
            subRL->_parent = parent;

        subR->_parent = parent->_parent;
        parent->_parent = subR;
        subR->_left = parent;

        parent->_bf = 0;
        subR->_bf = 0;

        parent = subR;
    }

    void RotateR(Node*& parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        parent->_left = subLR;
        if (subLR != NULL)
            subLR->_parent = parent;

        subL->_parent = parent->_parent;
        subL->_right = parent;
        parent->_parent = subL;
        parent->_bf = 0;
        subL->_bf = 0;

        parent = subL;
    }



protected:
    Node* _root;
};




void test()
{
    BalanceTree<int, int> bt;
    int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        bt.Insert(arr[i], i);
    }

    bt.InOrder();
    cout << bt.Height() << endl;

    BalanceTree<int, int> bt1;
    int arr1[] = { 4,2,6,1,3,5,15,7,16,14 };
    for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
    {
        bt1.Insert(arr1[i], i);
    }

    bt1.InOrder();
    cout << bt1.Height() << endl;
}


#endif //__BALANCETREE_H__

2、AVL树的删除：

    删除相对而言跟插入差不多，都是需要理解过程的，对于删除，我们只需要先找到要删除的位置，然后分为三种情况：

1.左为空——–>直接连接到父节点上，只是需要判断连接到父节点的左还是右上

2.右为空——–>同上

3.左右都不为空：找到右边子树的最左节点，（这里还分为两种情况：没有左子节点和有）这里只分析有左子节点的了，一直往左遍历找到左子节点，交换左子节点和要删除的节点，然后将parent->left连到左子节点的右就行了，最后一步就是调节平衡因子了，从当前节点开始向上修改平衡因子，以及判断平衡因子有没有为2或者-2的情况，然后跟上面一样做处理。