AVL树详解&面试题-判断一棵树是否是平衡二叉树

上次写了关于二叉搜索树的分析，但是二叉搜索树有一个缺陷，就是当插入一个有序（或接近有序）的序列时，二叉搜索树就相当于一个链表了，搜索效率会特别低。那么，如何来改进呢？这就引入了AVL树（高度平衡二叉树），那么下面我们一起来了解一下AVL树吧！
AVL树的特征：
1、左右子树的高度差都不超过1；
2、左右子树都是AVL树；
3、每个节点都有一个平衡因子bf（blance fator ），其值为右子树的高度减去左子树的高度。
AVL树也是二叉搜索树，只是在插入节点时，进行了一些调整，使它的把树的高度降下来，做右子树高度差不超过1。做怎样的调整呢？这就要看一下AVL树的旋转啦！
当插入一个节点后，树的平衡因子bf=2时就对该树进行旋转，旋转又分为如下几种情况：
AVL树的旋转：

下面我给出我写的代码，只实现了插入操作，删除操作后期会加进来。
代码实现AVL树&判断一棵树是否是平衡二叉树：

#include<iostream>using namespace std;template<class K, class V>struct AVLTreeNode{    K _key;    V _value;    int _bf;   //平衡因子    AVLTreeNode * _parent;    AVLTreeNode * _left;    AVLTreeNode * _right;    AVLTreeNode(K k=K(),V v=V())        :_key(k)        ,_value(v)        ,_bf(0)        ,_parent(NULL)        ,_left(NULL)        ,_right(NULL)    {}};template<class K,class V>class AVLTree{    typedef AVLTreeNode<K, V> Node;public:    AVLTree()        :_root(NULL)    {}    bool Insert(const K key,const V value)    {        Node * cur = _root;        Node * parent = NULL;        if (cur == NULL)//_root为空/空树        {            _root = new Node(key, value);            _root->_bf = 0;            _root->_parent = NULL;            return true;        }        while (cur)//找插入节点位置节        {            if (cur->_key < key)            {                parent = cur;                cur = cur->_right;            }            else if (cur->_key > key)            {                parent = cur;                cur = cur->_left;            }            else//key值已存在，更新该key值得value            {                cur->_value = value;                return true;            }        }        //插入节点        Node * node = new Node(key, value);        if (parent->_key > key)        {            parent->_left = node;            node->_parent = parent;            node->_bf = 0;        }        else        {            parent->_right = node;            node->_parent = parent;            node->_bf = 0;        }        //更新平衡因子        cur = node;        while (parent)        {            if (parent->_left == cur)            {                parent->_bf--;            }            else if(parent->_right==cur)            {                parent->_bf++;            }            //根据平衡因子判断是否需要再调整祖先节点的平衡因子或调整树            if (parent->_bf == 0)            {                break;            }            else if (parent->_bf == 1 || parent->_bf == -1)            {                cur = parent;                parent = cur->_parent;            }            //如果不满足AVL树的性质，则旋转调整            else if (parent->_bf == -2)            {                if (parent->_left->_bf == -1)                {                    RotateR(parent->_left);//向右单旋                }                else if(parent->_left->_bf ==1)                {                    RotateLR(parent->_left);//左右双旋(先左单旋再向右单旋)                }                else                {                    printf("平衡因子异常\n");                    return false;                }            }            else if (parent->_bf == 2)            {                if (parent->_right->_bf == 1)                {                    RotateL(parent->_right);//向左单旋                }                else if(parent->_right->_bf==-1)                {                    RotateRL(parent->_right);//右左双旋(先右单旋，再左单旋)                }                else                {                    printf("平衡因子异常\n");                    return false;                }            }            else            {                printf("平衡因子异常\n");                return false;            }        }    }    int Height()//求二叉树的高度    {        return _Height(_root);    }    int Height(Node * root)    {        return _Height(root);    }    bool IsBlance()//判断一棵二叉树是否是平衡二叉树    {        return _IsBlance(_root);    }    void InOrder()//中序遍历树    {        _InOrder(_root);        cout << endl;    }protected:    void RotateL(Node * root)//向左单旋    {        Node *parent = root->_parent;        Node *subL = root->_left;        parent->_right = subL;        if (subL)        {            subL->_parent = parent;        }        if (parent == _root)        {            _root = root;            root->_parent = NULL;        }        else        {            if (parent->_parent->_left == parent)            {                parent->_parent->_left = root;            }            else            {                parent->_parent->_right = root;            }            root->_parent = parent->_parent;        }        root->_left = parent;        parent->_parent = root;        if (subL)        {            subL->_bf = 0;        }        parent->_bf = root->_bf = 0;    }    void RotateR(Node * root)//向右单旋    {        Node * parent = root->_parent;        Node * subR = root->_right;        parent->_left = subR;        if (subR)        {            subR->_parent = parent;        }        if (parent == _root)        {            _root = root;            root->_parent = NULL;        }        else        {            root->_parent = parent->_parent;            if (parent->_parent->_left == parent)            {                parent->_parent->_left = root;            }            else            {                parent->_parent->_right = root;            }        }        root->_right = parent;        parent->_parent = root;        if (subR)        {            subR->_bf = 0;        }        root->_bf = parent->_bf = 0;    }    void RotateLR(Node * root)//左右双旋    {        RotateL(root->_right);        RotateR(root->_parent);        Node* cur = root->_parent;        if (cur->_bf == 0)        {            cur->_left->_bf = 0;            cur->_right->_bf = 0;        }        else if(cur->_bf == 1)        {            cur->_bf = 0;            cur->_left->_bf = -1;            cur->_right->_bf = 0;        }        else if (cur->_bf == -1)        {            cur->_bf = 0;            cur->_left->_bf = 0;            cur->_right->_bf = 1;        }        else        {            printf("平衡因子异常\n");            return;        }    }    void RotateRL(Node*root)    {        RotateR(root->_left);         RotateL(root->_parent);        Node* cur = root->_parent;        if (cur->_bf == 0)        {            cur->_left->_bf = 0;            cur->_right->_bf = 0;        }        else if (cur->_bf == 1)        {            cur->_bf = 0;            cur->_left->_bf = -1;            cur->_right->_bf = 0;        }        else if (cur->_bf == -1)        {            cur->_bf = 0;            cur->_left->_bf = 0;            cur->_right->_bf = 1;        }        else        {            printf("平衡因子异常\n");            return;        }    }    int _Height(Node * root)    {        if (root == NULL)        {            return 0;        }        int left = _Height(root->_left) + 1;        int right = _Height(root->_right) + 1;        return left > right ? left : right;    }    bool _IsBlance(Node * root)    {        if (root == NULL)        {            return true;        }        int left = Height(root->_left);        int right = Height(root->_right);        if (abs(right - left) != abs(root->_bf))        {            cout << "平衡因子错误\n" << endl;            return false;        }        return (abs(right - left) < 2) && _IsBlance(root->_left) && _IsBlance(root->_right);    }    void _InOrder(Node * root)    {        if (root == NULL)        {            return;        }        _InOrder(root->_left);        cout << "key:" << root->_key << "value:" << root->_value<<" ";        _InOrder(root->_right);    }private:    Node * _root;};