AVL平衡树的旋转

AVL树是一种平衡查找树（每个节点左子树与右子树的高度差不超过1），这样可以保证树不偏向一边，使查找的时间复杂度降低。

需要给节点一个平衡因子_bf(右子树的高度减去左子树的高度)。

AVL树的插入分为下面几种情况：

在父节点的右子树插入节点，父节点的bf+1，如果父节点bf等于0,树平衡，插入成功，父节点bf等于1，右子树高度加1，接着向上调整。

在父节点的左子树插入节点，父节点的bf-1，如果父节点bf等于0,树平衡，插入成功，父节点bf等于-1，左子树高度加1，接着向上调整。

如果父节点的bf为2或者-2，树不平衡，进行旋转。

在较高右子树的右边插入节点需要进行左旋转。



pCur为插入节点，parent的bf为2，这时候把SubR提高,parent降低,重新满足平衡条件。


如果原右子树SubR的左子树SubRL不为空，SubR的左子树需要指向parent,所以把SubRL连到parent的右子树上。重新满足平衡。



–》


左单旋与右单旋为镜像，旋转方法相同，介绍省略。。

当父节点的bf为2,右子树的bf为-1,用上面方法没法一次旋转完成。（在较高右子树的左侧插入节点使进行右左双旋）。





先对SubR进行右单旋。





最后平衡





左右双旋为右左双旋的镜像，省略。。

代码实现：

#include <iostream>
using namespace std;
#include <assert.h>
#include <stdlib.h>

template <class K, class V>
struct AVLTreeNode
{
AVLTreeNode(const K& key = K(), const V& value = V())
:_key(key)
, _value(value)
, _pLeft(NULL)
, _pRight(NULL)
, _parent(NULL)
, _bf(0)
{}
AVLTreeNode *_pLeft;
AVLTreeNode *_pRight;
AVLTreeNode *_parent;
K _key;
V _value;
int _bf;

};

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

bool Insert(const K& key, const V& value)
{
if (NULL == _pRoot)
{
_pRoot = new Node(key, value);
return true;
}
Node *pCur = _pRoot;
Node *parent = NULL;
while (pCur)
{
if (key < pCur->_key)
{
parent = pCur;
pCur = pCur->_pLeft;
}
else if (key > pCur->_key)
{
parent = pCur;
pCur = pCur->_pRight;
}
else
return false;
}

pCur = new Node(key, value);
if (key < parent->_key)
{
parent->_pLeft = pCur;
--parent->_bf;
}
else
{
parent->_pRight = pCur;
++parent->_bf;
}
pCur->_parent = parent;

while (parent && parent->_bf != 0)
{
if (parent->_bf == 2)
{
if (pCur->_bf == 1)
_RotateL(parent);
else
_RotateRL(parent);
return true;
}
else if (parent->_bf == -2)
{
if (pCur->_bf == -1)
_RotateR(parent);
else
_RotateLR(parent);
return true;
}

if (parent->_bf == 1)
{
pCur = parent;
parent = parent->_parent;
if (parent)
++parent->_bf;
else
return true;
}
else if (parent->_bf == -1)
{
pCur = parent;
parent = parent->_parent;
if (parent)
--parent->_bf;
else
return true;
}
}
}

bool IsBalance()
{
return IsBalanceTree(_pRoot);
}

void InOrder()
{
cout << "中序：";
_InOrder(_pRoot);
cout << "end" << endl;
}
private:
void  _RotateL(Node* parent)
{
Node *SubR = parent->_pRight;
Node *SubRL = SubR->_pLeft;

parent->_pRight = SubRL;
if (SubRL != NULL)
SubRL->_parent = parent;

Node *pPParent = parent->_parent;

parent->_parent = SubR;
SubR->_pLeft = parent;
SubR->_parent = pPParent;

if (NULL == pPParent)
_pRoot = SubR;
else if (pPParent->_pLeft == parent)
{
pPParent->_pLeft = SubR;
}
else
{
pPParent->_pRight = SubR;
}

SubR->_bf = 0;
parent->_bf = 0;
}

void  _RotateR(Node* parent)
{
Node *SubL = parent->_pLeft;
Node *SubLR = SubL->_pRight;
parent->_pLeft = SubLR;
if (SubLR != NULL)
SubLR->_parent = parent;

Node *pPParent = parent->_parent;

parent->_parent = SubL;
SubL->_pRight = parent;
SubL->_parent = pPParent;

if (NULL == pPParent)
_pRoot = SubL;
else if (pPParent->_pLeft == parent)
{
pPParent->_pLeft = SubL;
}
else
{
pPParent->_pRight = SubL;
}

SubL->_bf = 0;
parent->_bf = 0;
}

void _RotateRL(Node *parent)
{
_RotateR(parent->_pRight);
_RotateL(parent);
parent->_pRight->_bf = -1;
}

void _RotateLR(Node *parent)
{
_RotateL(parent->_pLeft);
_RotateR(parent);
parent->_pLeft->_bf = 1;
}

void _InOrder(Node *proot)
{
if (NULL == proot)
return;
_InOrder(proot->_pLeft);
cout << proot->_value << " ";
_InOrder(proot->_pRight);
}

int Hight(Node *proot)
{
if (NULL == proot)
return 0;
if (proot->_pLeft == NULL && proot->_pRight == NULL)
return 1;
int LeftHight = Hight(proot->_pLeft);
int RightHight = Hight(proot->_pRight);
return 1 + ((LeftHight > RightHight) ? LeftHight : RightHight);
}

bool IsBalanceTree(Node *proot)
{
if (NULL == proot)
return true;
if (proot->_bf >= 2 || proot->_bf <= -2)
{
cout << proot->_key<<"平衡因子大于2！" << endl;
return false;
}
if (Hight(proot->_pRight) - Hight(proot->_pLeft) != proot->_bf)
{
cout <<proot->_key<<"  平衡因子不正确!" << endl;
return false;
}
if (IsBalanceTree(proot->_pLeft) && IsBalanceTree(proot->_pRight))
return true;
}
private:
Node *_pRoot;
};
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
AVLTree<int, int> avtree;
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
{
avtree.Insert(arr[i], arr[i]);
avtree.IsBalance();
}
avtree.InOrder();
getchar();
return 0;
}