在二叉搜索树来查询数据的结构里面，树形结构并不是一个平衡的二叉树。在有些情况下效率明显不是很高（例如，左单支或者右单支）。
在AVL树里面，每个子树的高度相差不大于1，即最高的子树和最低的子树之间相差最高为1。
例如：这里规定是右子树的高度-左子树的高度作为平衡因子。

当在整个树里面的结点的平衡因子含有绝对值大于1的时候就需要对树进行调整。
情况1：

情况2：

情况3：

情况4：

当每次进行插入和删除的同时，需要对结点的平衡因子进行相应的调整。
实现代码：
（只实现结点的插入和调整）

#ifndef _AVLTREE_H
#define _AVLTREE_H
#include<iostream>
using namespace std;

template<class T ,class V> struct AVLTreeNode {
    AVLTreeNode(T d)
    :left(NULL)
    ,right(NULL)
    ,_parent(NULL)
    ,fd(0)
    ,value(d)
    {}

    AVLTreeNode<T,V>* left;
    AVLTreeNode<T,V>* right;
    AVLTreeNode<T,V>* _parent;
    int fd;
    int value;
};

template<class T,class V> class AVLTree {
    public:
    typedef struct AVLTreeNode<T,V> Node;
    AVLTree(T* arr,size_t size)
    {
        _root = NULL;
        if(NULL == arr)
            return ;
        for(int i=0;i<size;i++)
            Insert(arr[i]);
    }
    void Insert(T d)
    {
        _Insert(_root,d);
    }
    void Inorder()
    {
        _Inorder(_root);
        cout<<endl;
    }
    Node* Find(T d)
    {
        return _Find(_root ,d);
    }

private:

    Node* _Find(Node* root,T d)
    {
        while(root)
        {
            if(d < root->value)
                root = root->left;
            else if(d > root->value)
                root = root->right;
            else
                return root;
        }
    }

    void _Inorder(Node* root)
    {
        if(root)
        {
            _Inorder(root->left);
            cout<<root->value<<" ";
            _Inorder(root->right);
        }
    }

    void _rotate_R(Node* parent)//情况1
    {
        Node* pparent = parent->_parent;    //记录当前节点的前一个结点
        Node*subL = parent->left;
        Node* subLR = subL->right;
        if(subLR)
            subLR->_parent = parent;
        subL->right = parent;
        parent->_parent = subL;
        parent->left = subLR;

        if(pparent == NULL)
            _root = subL;
        else if(pparent->left == parent)
            pparent->left = subL;
        else
            pparent->right = subL;

        subL->_parent = pparent;
        subL->fd = parent->fd = 0;
    }

    void _rotate_L(Node* parent)//情况2
    {
        Node* subR = parent->right;
        Node* subRL = subR->left;
        Node* pparent = parent->_parent;

        if(subRL)
            subRL->_parent = parent;
        subR->left = parent;
        parent->_parent = subR;
        parent->right = subRL;

        if(pparent == NULL)
            _root = subR;
        else if(pparent->left == parent)
            pparent->left = subR;
        else 
            pparent->right = subR;
        subR->_parent = pparent;
        subR->fd = parent->fd = 0;
    }
    void _rotate_RL(Node* parent)        //情况3
    {
        _rotate_R(parent);
        _rotate_L(parent);
    }
    void _rotate_LR(Node* parent)        //情况4
    {
        _rotate_L(parent);
        _rotate_R(parent);
    }

    void _Insert(Node* root,T d)
    {
        Node* tmp = new Node(d);
        Node* parent = NULL;
        if(NULL == root)
        {
            _root = tmp;
            return ;
        }
        while(root)
        {
            parent = root;
            if(root && d < root->value )
                root = root->left;
            else 
                root =  root->right;
        }
        if(d < parent->value)
        {
            parent->left = tmp;
            tmp->_parent = parent;
        }
        else
        {
            parent->right = tmp;
            tmp->_parent = parent;
        }
        while(tmp)
        {
            if(NULL == parent)
                return;
            if(tmp == parent->left)
                parent->fd--;
            else
                parent->fd++;
            if(parent->fd == 0)
                break;
            else if(parent->fd == 1 || parent->fd == -1)
            {
                tmp = parent;
                parent = tmp->_parent;
            }
            else 
            {
                if(parent->fd == 2 )
                {
                    if(tmp->fd = 1)
                    {
                        _rotate_L(parent);
                    }
                    else
                        _rotate_RL(parent);
                }
                else
                {
                    if(tmp->fd == 1)
                        _rotate_LR(parent);
                     else
                        _rotate_R(parent);
                }
            }
        }
    }


    Node* _root;
};

#endif