这篇文章用来复习AVL的平衡操作,分别会介绍其旋转操作的递归与非递归实现,但是最终带有插入示例的版本会以递归呈现.
下面这张图绘制了需要旋转操作的8种情况.(我要给做这张图的兄弟一个赞)后面会给出这八种情况对应平衡实现.
[1]
情况1-2:
这种需要旋转的结构一般称之为LL型,需要右旋 (顺时针旋转).
我用一个图来抽象一下这两个情况,画的不好,我尽量表达吧.
此时需要对A进行平衡操作,方法为:
- 将A的左子树换为B的右子树.
- B的右子树换为A.
- 非递归实现的代码为:
1 void rotate_right(AVLTree &A){
2
3 AVLTree leftChild = A->left;
4
5 A->left = leftChild->right;
6
7 leftChild->right = A;
8
9 // 别忘了让父节点建立平衡后的连接
10
11 A = leftChild;
12
13 }
非递归的操作在旋转前会充分考虑所有的旋转情况,目的是提早调整A下面各节点的高度.
之后再进行旋转操作,这一点与递归的不同,可见递归是平衡完后再进行的高度调整.
- 递归实现代码为:
1 Position CAVLTree::singleRotateWithLeft(Position _K){
2 Position K0;
3 K0 = _K->left;
4 _K->left = K0->right;
5 K0->right = _K;
6
7 _K->Height = max(getHeight(_K->left),getHeight(_K->right)) + 1;
8 K0->Height = max(getHeight(K0->left),getHeight(K0->right)) + 1;
9
10 // 返回新的节点以替换
11 return K0;
12 }
情况3-4:
这种需要旋转的结构一般称之为RR型,需要左旋(逆时针旋转).
需要对A进行平衡操作,方法为:
- 将A的右子树换为B的左子树;
- B的左子树换为A
- 非递归的实现为:
void rotate_left(AVLTree &A){
AVLTree rightChild = A->right;
A->right = rightChild ->left;
rightChild->left = A;
A = rightChild;
}
- 递归实现为:
Position CAVLTree::singleRotateWithRight(Position _K){
Position K0;
K0 = _K->right;
_K->right = K0->left;
K0->left = _K;
_K->Height = max(getHeight(_K->left),getHeight(_K->right)) + 1;
K0->Height = max(getHeight(K0->left),getHeight(K0->right)) + 1;
return K0;
}
情况5-6:
这种需要旋转的结构一般称之为LR型,需要双旋转,即两次单旋.分别为左旋和右旋.
需要对A进行平衡操作,方法为:
- 对B(A->left)做左旋
- 对A做右旋
这个递归与非递归的方式都是一样的.
- 非递归:
rotate_left(A->left); rotate_right(A);
- 递归:
Position CAVLTree::doubleRotateWithLeft(Position _K){
_K->left = singleRotateWithRight(_K->left);
return singleRotateWithLeft(_K);
}
但是有没有一次性到位的方法呢?有的
我把非递归的两个函数展开:
发现最后一步都是确定与父节点的关系,并不是旋转中的具体过程,于是可以简化为这样:
AVLTree leftChild = A->left; AVLTree leftRightChild = leftChild->left; // 左旋 leftChild->right = leftRightChild->left; leftRightChild->left = leftChild; // 右旋 A->left = leftRightChild->right; leftChild->right = A;
情况7-8:
这种需要旋转的结构一般称之为RL型,需要双旋转,即两次单旋.分别为右旋和左旋.
需要对A进行平衡操作,方法为:
- 对B进行右旋
- 对A进行左旋
同样,递归与非递归版本是一样的.
- 非递归:
rotate_right(A->left); rotate_left(A);
- 递归:
Position CAVLTree::doubleRotateWithRight(Position _K){
_K->right = singleRotateWithLeft(_K->right);
return singleRotateWithRight(_K);
}
同样,也有一次性到位的方法:
AVLTree rightChild = A->right; AVLTree rightLeftChild = rightChild->left; // 右旋 rightChild->left = rightLeftChild->right; rightLeftChild->right = rightChild; // 左旋 A->right = rightLeftChild->left; rightLeftChild->left = A;
下面是实现部分:
0.结构声明[2]:
struct AvlNode;
typedef AvlNode * AvlTree;
typedef AvlNode * Position;
typedef int ELEMENT;
struct AvlNode
{
AvlNode():data(),left(nullptr),right(nullptr),Height(){}
ELEMENT data;
AvlTree left;
AvlTree right;
int Height;
};
1.类中提供的API
class CAVLTree
{
public:
CAVLTree(void);
~CAVLTree(void);
size_t _insert_(ELEMENT &_data);
int getTreeHeight();
void showThisTree();
private:
size_t size;
AvlTree AvlTreeRoot;
private:
Position insert_specific(ELEMENT &_data,AvlTree &_T);
void showThisTree_specific(AvlTree _T);
int getTreeHeight_specific(AvlTree _T);
int max(int _a,int _b);
int getHeight(Position _K);
// 对于左左的分支,采用右旋
Position singleRotateWithLeft(Position _K);
//对于右右的分支,采用左旋
Position singleRotateWithRight(Position _K);
// 对于左右的分支,采用先左旋后右旋
Position doubleRotateWithLeft(Position _K);
// 对于右左的分支,采用先右旋后左旋
Position doubleRotateWithRight(Position _K);
};
2.获取高度:
因为在max()函数获取结束后需要+1,所以这里的目的是将叶节点的Height想办法为0.
int CAVLTree::getHeight(Position _K){
return (_K == nullptr )?-1:_K->Height;
}
3.插入操作:
- 递归
通过回溯的方式找到插入的位置,先平衡后调整高度;
哈哈,有一个很有趣的细节为什么同时判断高度差一个是
if(getHeight(_T->left) - getHeight(_T->right) == 2)
而另一个是
if (getHeight(_T->right) - getHeight(_T->left) == 2)
因为这里已经知道了插入发生在哪边了,所以肯定是插入的那边会有破坏平衡的可能,不会造成尴尬的(小-大)的局面.
Position CAVLTree::insert_specific(ELEMENT &_data,AvlTree &_T){
if (!_T)
{
_T = new AvlNode;
_T->data = _data;
_T->Height = 0;
size++;
}
else if(_data < _T->data)
{
_T->left = insert_specific(_data,_T->left);
if(getHeight(_T->left) - getHeight(_T->right) == 2)
{
// 根据新插入的节点所在位置来判断使用什么旋转
if(_data < _T->left->data)
{
// 需要右旋
_T = singleRotateWithLeft(_T);
}
else
{
// 需要先左旋后右旋
_T = doubleRotateWithLeft(_T);
}
}
}
else if (_data > _T->data)
{
_T->right = insert_specific(_data,_T->right);
if (getHeight(_T->right) - getHeight(_T->left) == 2)
{
if (_data > _T->right->data)
{
// 需要左旋
_T = singleRotateWithRight(_T);
}
else
{
// 需要先右旋再左旋
_T = doubleRotateWithRight(_T);
}
}
}
_T->Height = max(getHeight(_T->left) , getHeight(_T->right)) + 1 ;
return _T;
}
- 非递归[3]:
可以发现,非递归的实现是先调整高度再平衡,但是要提前考虑所有情况.
考虑左子树的情况:
void leftBalance(AVLNode* &t)
{
AVLNode* lc = NULL;
AVLNode* rd = NULL;
lc = t->lchild;
switch(lc->bf)
{
case LH: //顺时针旋转(即右旋)
t->bf = EH;
lc->bf = EH;
R_Rotate(t);
break;
case EH: //删除节点时会发生,插入不会发生
t->bf = LH;
lc->bf = RH;
R_Rotate(t);
break;
case RH: //先左旋后右旋
rd = lc->rchild;
switch(rd->bf)
{
case LH:
t->bf = RH;
lc->bf = EH;
break;
case EH:
t->bf = EH;
lc->bf = EH;
break;
case RH:
t->bf = EH;
lc->bf = LH;
break;
}
rd->bf = EH;
L_Rotate(t->lchild);//不能写L_Rotate(lc);采用的是引用参数
R_Rotate(t);
break;
}
}
考虑右子树的情况:
void rightBalance(AVLNode* &t)
{
AVLNode* rc = NULL;
AVLNode *ld = NULL;
rc = t->rchild;
switch(rc->bf)
{
case RH: //逆时针旋转(即左旋)
t->bf = EH;
rc->bf = EH;
L_Rotate(t);
break;
case EH: //删除节点时会发生,插入不会发生
t->bf = RH;
rc->bf = LH;
L_Rotate(t);
break;
case LH: //先右旋后左旋
ld = rc->lchild;
switch(ld->bf)
{
case LH:
t->bf = EH;
rc->bf = RH;
break;
case EH:
t->bf = EH;
rc->bf = EH;
break;
case RH:
t->bf = LH;
rc->bf = EH;
break;
}
ld->bf = EH;
R_Rotate(t->rchild);//不能写R_Rotate(rc);采用的是引用参数
L_Rotate(t);
break;
}
}
总结:
递归真是神奇啊,对子树的处理递归的很漂亮,代码量是一方面,代码逻辑的清晰性也是非递归程序鲜有的.
用这个来学习递归算法真是好工具,希望对于我后面复习图论有帮助.
这篇文章中所述的非递归程序我并没有实现,肯定有疏忽的地方,欢迎大家指正.
完整示例中还有一个showThisTree(),它可以打印出漂亮的平衡二叉树.
相关代码请见我的github
[1] AVL树的旋转操作 图解 最详细
[2] left 等价 leftChild,同理,right 也等价 rightChild.
[4] 参考教材 数据结构与算法分析：C语言描述（原书第2版）[美] MarkAllenWeiss 著