对于上篇的二叉搜索树，我们可以讨论一下它的时间复杂度。在最好的情况下，也就是这颗二叉搜索树是一棵完全二叉树的情况下，它的查找效率是lgN（以2为底N的对数，这里为了方便起见这样写），但是在最坏的情况下，也就是说，在插入的时候是有序插入，这颗二叉搜索树达到了以下的状态

这个时候这颗二叉搜索是一棵极度不平衡的树，它的时间复杂度是N。显然如果这颗树存了10亿个数据，那么最坏的情况要查找10亿次，而对于lgN这种算法，只需要30次就够了，两者的查找效率显而易见。所以我们在二叉搜索树的基础上，提出了二叉平衡搜索树的概念。本篇暂时只讲二叉平衡搜索树的一个分支AVL树，在下一篇我们将讲到另一个分支红黑树。

AVL树的特点
AVL树右称为高度平衡的二叉搜索树，它能够保持二叉树的高度平衡，减少搜索长度，那么它是怎么来实现的呢？
1.首先它是一棵二叉搜索树，它具有二叉搜索树所具有的所有性质。
2.左右子树的高度之差的绝对值不超过1
3.树中的每个左子树和右子树都是AVL树
4.每个节点多了一个平衡因子（_bf）的概念，它等于右子树的高度减去左子树的高度，它的绝对值不超过1（即为1，-1,0）。

若有N个数，这颗树的高度可以保持在lgN，对于插入查找删除的操作效率都是lgN。

AVL树的增（insert）
对于AVL树，增是它的重点也是它的难点，是它最难理解的地方。会了增，其实删除也是很好理解的。所以本篇我们只讨论增，以及它在增的时候是如何保持它的高度平衡的。

1.首先和二叉搜索树一样的是，一样也是比较插入的节点与当前节点的key值，找到一个为空的位置然后进行插入。
2.如果父亲的左树插入的，平衡因子_bf–；右树增加的，平衡因子 _bf++。
3.插入了节点，会影响它祖先这一条线上的高度，我们通过parent的_bf在通过调整之后的值，来作出相应的平衡调整。
①._bf变为0，说明原来的 _bf是1或-1，子树的高度没有变。

②._bf变为1或-1，说明原来的 _bf是0，子树的高度变了，需要继续向上调整。

③._bf变为2或-2，说明原来的 _bf是1或-1，这个时候就需要通过旋转来调整树的高度。

下面来仔细介绍一下旋转这种方法。
1.左旋

如上图所示，10的_bf原来是1,20的 _bf原来是0，在20的右树插入一个节点之后，10的 _bf变为了2,20的 _bf变为了1，这个时候就要以10这个节点为轴进行左旋，将b给10的右，10变成20的左，这样一旋转之后，两者的平衡因子都变成了0。由上图可知，发生左旋的条件是parent的 _bf是2，parent的右孩子的 _bf是1。
2.右旋

右旋与左旋的原理是相似的，这里就不再重复了，只是方向反了一下。发生右旋的条件是parent的_bf是-2，parent的左孩子的 _bf是-1。
3.右左双旋

顾名思义，如上图，右左双旋就是先以30为轴进行一个右旋，再以10为轴进行一个左旋。这有三种情况，一种就是在如上图在c树插入了一个节点改变了高度，另一种就是在b树插入了一个节点，还有一种是20就是新增节点，b、c都不存在。可以发现的是，进行右左双旋的条件是，parent的_bf是2,parent的右孩子的 _bf是-1。
4.左右双旋

与右左双旋类似，先进行左旋，再进行右单旋。也是有三种情况，b插入，c插入，20是新增节点。进行左右双旋的条件是，parent的_bf是-2，parent的左孩子的 _bf是1。

下面我们通过代码来实现一棵AVL树。

#pragma once

#include <iostream>
using namespace std;

#include <assert.h>

template <class K,class V>
struct AVLTreeNode
{
    K _key;
    V _value;
    int _bf;

    AVLTreeNode<K, V>* _left;
    AVLTreeNode<K, V>* _right;
    AVLTreeNode<K, V>* _parent;

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

template <class K,class V>
class AVLTree
{
    typedef AVLTreeNode<K, V> Node;
public:
    AVLTree()
        :_root(NULL)
    {}

    bool Insert(const K& key, const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);
            return true;
        }

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

        cur = new Node(key, value);
        //让parent的左或右指向cur，cur的parent指向parent
        if (parent->_key < key)
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_left = cur;
            cur->_parent = parent;
        }

        //更新平衡因子
        while (parent)
        {
            //左增加，_bf--
            if (cur == parent->_left)
            {
                parent->_bf--;
            }
            else
            //右增加，_bf++
            {
                parent->_bf++;
            }

            //根据parent更新后的平衡因子调整
            if (parent->_bf == 0)
            //子树高度没变，不用调整，直接退出
            {
                break;
            }
            else if (parent->_bf == 1 || parent->_bf == -1)
            //子树高度变了，继续向上调整
            {
                cur = parent;
                parent = cur->_parent;
            }
            else if (parent->_bf == 2 || parent->_bf == -2)
            //进行旋转
            {
                if (parent->_bf == 2)
                {
                    if (cur->_bf == 1)
                    {
                        RotateL(parent);//左旋
                    }
                    else
                    {
                        RotateRL(parent);//右左双旋
                    }
                }
                else
                {
                    if (cur->_bf == -1)
                    {
                        RotateR(parent);//右旋
                    }
                    else
                    {
                        RotateLR(parent);//左右双旋
                    }
                }
                //旋转之后不用调整了，直接跳出循环
                break;
            }
            else
            //走到这肯定是不平衡了，断言失败
            {
                assert(false);
            }
        }
        return true;
    }

    bool IsBalance()
    {
        //return _IsBalance(_root);
        int height = 0;
        return _IsBalance(_root,height);
    }

    void Inorder()
    {
        _Inorder(_root);
        cout << endl;
    }
protected:
    bool _IsBalance(Node* root)
        //效率慢
    {
        if (root == NULL)
        {
            return true;
        }
        //右树的高度-左树的高度和bf比较
        int leftHeight = _Height(root->_left);
        int rightHeight = _Height(root->_right);

        return abs(rightHeight - leftHeight) < 2
            && _IsBalance(root->_left)
            && _IsBalance(root->_right);
    }

    bool _IsBalance(Node* root, int& height)
    {
        if (root == NULL)
        {
            height = 0;
            return true;
        }

        int leftHeight = 0;
        if (_IsBalance(root->_left, leftHeight) == false)
        //只要有一个节点的平衡因子不对立马返回错误，不用再算后面的
        {
            return false;
        }

        int rightHeight = 0;
        if (_IsBalance(root->_right, rightHeight) == false)
        {
            return false;
        }

        if (root->_bf != rightHeight - leftHeight)
        //只要平衡因子不等于右树高度-左树高度就是错误
        {
            cout << "平衡因子异常" << root->_key << endl;
            return false;
        }

        height = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
        //返回左树和右树高的那个的高度+1
        return abs(leftHeight - rightHeight) < 2;
    }

    int _Height(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        int left = _Height(root->_left);
        int right = _Height(root->_right);

        return left > right ? left + 1 : right + 1;
        //返回左树和右树高的那个的高度+1
    }

    void RotateR(Node* parent)//右旋
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        Node* grandparent = parent->_parent;

        parent->_left = subLR;

        if (subLR)
            //如果subLR存在，则将它的父亲指向parent
        {
            subLR->_parent = parent;
        }

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

        if (grandparent == NULL)
            //parent是根节点
        {
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (parent == grandparent->_left)
            {
                grandparent->_left = subL;
            }
            else
            {
                grandparent->_right = subL;
            }
            subL->_parent = grandparent;
        }
        //更新它们的平衡因子
        subL->_bf = parent->_bf = 0;
    }
    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        Node* grandparent = parent->_parent;

        parent->_right = subRL;
        if (subRL)
        {
            subRL->_parent = parent;
        }

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

        if (grandparent == NULL)
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else
        {
            if (grandparent->_left == parent)
            {
                grandparent->_left = subR;
            }
            else
            {
                grandparent->_right = subR;
            }

            subR->_parent = grandparent;
        }
        subR->_bf = parent->_bf = 0;
    }

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

        int bf = subRL->_bf;
        RotateR(subR);
        RotateL(parent);

        if (bf == -1)
            //在subRL的左边插入了一个节点
        {
            parent->_bf = 0;
            subR->_bf = 1;
            subRL->_bf = 0;
        }
        else if (bf == 1)
            //在subRL的右边插入了一个节点
        {
            parent->_bf = -1;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else if (bf == 0)
            //subRL是新增节点
        {
            parent->_bf = 0;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else
        {
            assert(false);
        }
    }
    void RotateLR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        int bf = subLR->_bf;
        RotateL(subL);
        RotateR(parent);

        if (bf == -1)
            //在subLR的左边插入了一个节点
        {
            parent->_bf = 0;
            subL->_bf = 1;
            subLR->_bf = 0;
        }
        else if (bf == 1)
            //在subLR的右边插入了一个节点
        {
            parent->_bf = -1;
            subL->_bf = 0;
            subLR->_bf = 0;
        }
        else if (bf == 0)
            //subLR是新增节点
        {
            parent->_bf = 0;
            subL->_bf = 0;
            subLR->_bf = 0;
        }
        else
        {
            assert(false);
        }
    }

    bool _Inorder(Node* root)
    {
        if (root == NULL)
        {
            return false;
        }

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

        return true;
    }
private:
    Node* _root;
};

void TestAVLTree()
{
    int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 }; AVLTree<int, int> t; for (size_t i = 0; i < sizeof(a) / sizeof(int); ++i) { t.Insert(a[i], i); t.Inorder(); cout << "IsBalance()?" << t.IsBalance() << endl; } }

这里我们除了实现了一个Insert，还实现了一个判平衡的函数Isbalance。在代码中我们可以看到，用注释注释了的判平衡的算法效率很低，它的思想有一点像用递归方法求斐波那契数列，会有重复求解的过程，效率非常低，所以这里只写出来并不用。

最终测试的代码如下，我们每插入一个值就判断这棵树平不平衡。