1.AVL树的定义
AVL树又称为高度平衡的二叉搜索树，在此基础上，AVL树节点的构造我们增加了_bf这个成员，来表示平衡因子，它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度。
2.AVL树的性质
（1） 左子树和右子树的高度之差的绝对值不超过1
（2）树中的每个左子树和右子树都是AVL树
（3）每个节点都有一个平衡因子(balance factor–bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子
树的高度 )
3.AVL树的效率
一棵AVL树有N个节点，其高度可以保持在log2N，插入/删除/查找的时间复杂度也是log2N。
4.节点的定义
template<class K, class V> struct AVLTreeNode {
AVLTreeNode<K,V>* _left;
AVLTreeNode<K,V>* _right;
AVLTreeNode<K,V>* _parent;
K _key;
V _value;
int _bf; // 平衡因子
AVLTreeNode(const K& key, const V& value)
:_left(NULL)
,_right(NULL)
,_parent(NULL)
,_key(key)
,_value(value)
,_bf(0)
{}
};一棵AVL树，当插入新节点的时候，会破坏原来的平衡因子，所以我们要用一些调整办法来解决问题，调整结构分为4种，左旋，右旋，左右双旋，右左双旋。通过旋转，降低树的高度。
左旋的情况：（parent->bf=2.cur->bf=1）
将 parent 的 right 指针，指向cur 的left结点；同时cur的left 指针，指向parent 结点。cur 结点继承了原来parent结点在该树（子树）中的根节点的位置，如果原来的parent结点还有父结点，cur需要和上一层的结点保持连接关系。旋转之后，原来的parent结点和cur结点的平衡因子都变为0 。
代码：
void RotateL(Node* parent)//左旋
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
Node* ppNode = parent->_parent;//subL->_parent = parent->_parent;
parent->_parent = subR;
if (ppNode==NULL)
{
_root = subR;
subR->_parent = NULL;
}
else
{
if (parent == ppNode->_left)
ppNode->_left = subR;
else
ppNode->_right = subR;
subR->_parent = ppNode;
}
subR->_bf = parent->_bf = 0;
}右旋的情况：（parent->bf=-2;cur->bf=-1）
将 parent 结点的left指针，指向cur的右节点，cur结点的右指针，指向parent结点。同时，cur结点将要继承在该子树中parent结点的根节点的位置。即如果parent结点有它自己的父节点，cur将要和parent结点的父节点保持指向关系。旋转之后，原来的parent结点和cur结点的平衡因子都变为0 。
代码如下：
void RotateR(Node* parent)//右旋
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
subL->_right = parent;
Node* ppNode = parent->_parent;
parent->_parent = subL;
if (ppNode==NULL)
{
_root = subL;
subL->_parent = NULL;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else
{
ppNode->_right = subL;
}
subL->_parent = ppNode;
}
parent->_bf = subL->_bf = 0;
}左右双旋：（parent->bf=-2,cur->bf=1）
它比单旋要更复杂，分为三步进行
1>以cur为根进行左旋
2>以parent为根进行右旋
3>调节平衡因子
特别说明一下，根据新元素的插入位置的不同，旋转完成后,平衡因子的调整也是不同的，看下面三种情况：
代码：
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(parent->_left);
RotateR(parent);
if (bf == 0)
{
parent->_bf = 0;
subL->_bf = 0;
subLR->_bf = 0;
}
else if (bf == 1)
{
parent->_bf = 0;
subL->_bf = -1;
subLR->_bf = 0;
}
else //-1
{
parent->_bf = 1;
subL->_bf = 0;
subLR->_bf = 0;
}
}右左双旋：（parent->bf=2，cur->bf=-1）
他的调整步骤和左右双旋一样，平衡因子的三种调整情况为：
代码：
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == 0)
{
parent->_bf = 0;
subR->_bf = 0;
subRL->_bf = 0;
}
else if (bf == 1)
{
parent->_bf = -1;
subR->_bf = 0;
subRL->_bf = 0;
}
else//-1
{
parent->_bf = 0;
subR->_bf = 1;
subRL->_bf = 0;
}
}接下来我们看一下他的插入算法，因为AVL树也是一种搜索树，满足搜索树的性质，所以插入节点的时候是按照搜索树的原理进行插入的。正确插入之后，根据节点的平衡因子的大小，进行调整与旋转。
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;
}
cur = new Node(key,value);
if (parent->_key > key)
{
parent->_left = cur;
cur->_parent = parent;
}
else
{
parent->_right=cur;
cur->_parent = parent;
}
//更新平衡因子
while (parent)
{
if (parent->_left==cur)
parent->_bf--;
else
parent->_bf++;
if (parent->_bf == 0)
break;
else if ((parent->_bf == 1) || (parent->_bf == -1))//向上调平衡
{
cur = parent;
parent = parent->_parent;
}
else if ((parent->_bf == 2) || (parent->_bf == -2))
{
if (parent->_bf == 2)
{
Node* subR = parent->_right;
if (subR->_bf == 1)
RotateL(parent);
else//-1
RotateRL(parent);
}
else//parent->_bf == -2
{
Node* subL = parent->_left;
if (subL->_bf == -1)
RotateR(parent);
else
RotateLR(parent);
}
break;
}
else
{
cout << "平衡因子异常" << endl;
}
}
return true;
}插入调整完成之后，我们就可以判断平衡啦，用一个函数来判断平衡
bool IsBalance()
{
return _IsBalance(_root);
}
bool _IsBalance(Node* root)
{
if (root == NULL)
return true;
int l = _Height(root->_left);
int r = _Height(root->_right);
if ((r - l) != root->_bf)
{
cout << "平衡因子异常：" << root->_key << endl;
return false;
}
return abs(r - l ) <= 1
&& _IsBalance(root->_left)
&& _IsBalance(root->_right);
}
int _Height(Node* root)
{
if (root == NULL)
return 0;
int l = _Height(root->_left);
int r = _Height(root->_right);
return l > r ? l + 1 : r + 1;
}