AVL树
1. AVL树的概念
二叉搜索树虽可以缩短查找的效率,但如果数据有序或接近有序二叉搜索树将退化为单支树,查找元素相当于在顺序表中搜索元素,效率低下。因此,两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整),即可降低树的高度,从而减少平均搜索长度。
一棵AVL树或者是空树,或者是具有以下性质的二叉搜索树:
- 它的左右子树都是AVL树
- 左右子树(所有的)高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
2. AVL树节点的定义
template<class K,class V>
struct AVLTreeNode
{
//使用三叉连,这样也比较便于找到parent节点
AVLTreeNode<K,V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
pair<K, V> _kv;
int _bf;//平衡因子 左右高度差 用来衡量这棵树是否平衡
AVLTreeNode(const pair<K, V>& kv)
:_left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _kv(kv)
, _bf(0) //刚创建出来的节点左右子树都是空,所以平衡因子给0
{}
};
3. AVL树的插入
AVL树就是在二叉搜索树的基础上引入了平衡因子,因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步:
- 按照二叉搜索树的方式插入新节点
- 调整节点的平衡因子(这也是和二叉搜索树不同的关键所在)
新增节点可能会影响它到根结点这条路径上的祖先。
- 新增结点(向上更新的过程中,cur也有可能是高度变化的子树的根)cur == parent->_right(在右边),parent->_bf++
- 新增结点(向上更新的过程中,cur也有可能是高度变化的子树的根)cur == parent->_left(在左边),parent->_bf- -
- 更新完parent平衡因子以后,又分为了3中情况
- a. parent->_bf == 0,说明parent所在的子树的高度没有发生变化(没有更新前,parent->_bf是1或者-1,有一边高,现在变成了0,说明把矮的那边给填上了),所以不会对上层路径上的结点构成影响,因此更新结束。
- b. parent->_bf == 1或者 -1,说明parent所在的子树的高度改变了,对上一层有影响,需要继续向上更新。
- c. parent->_bf == 2或者-2,说明此时parent所在的子树已经不平衡,需要旋转处理
3.1 AVL树的旋转
如果在一棵原本是平衡的AVL树中插入一个新节点,可能造成不平衡,此时必须调整树的结构,使之平衡化。根据节点插入位置的不同,AVL树的旋转分为四种:但是这里首先分析一下所给的树,为什么给的是抽象模型。
3.1.1 右单旋
新结点插入较高左子树的左侧:
为了能够更好的理解这段代码,需要在借助下面的这个图。
- b去做60的左子树
- 60做30的右子树
- 30结点成了这棵树新的根
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
//但是subLR有可能是空的,那么下面这个代码就会崩
if (subLR)
subLR->_parent = parent;//此树为一个三叉链,所以一定要注意更新父节点的指针
//如果这个右旋只是一颗树的一部分,那么后面会改变最开始的父指针,所以要预先保留下来
Node* parentParent = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
//此时还需要最后一步,把根结点换掉
if (parent == _root)
{
_root = subL;
_root->_parent = nullptr;
}
else
{
//此时你需要把30这个结点连接住,但是应该连接在哪一边还需要进行判断
if (parentParent->_left == parent)
{
parentParent->_left = subL;
}
else
{
parentParent->_right = subL;
}
subL->_parent = parentParent;
}
//还有平衡因子的更新
subL->_bf = parent->_bf = 0;
}
3.1.2 左单旋
新节点插入较高右子树的右侧:左单旋
为了能够更好的理解这段代码,需要在借助下面的这个图。
- b去做了30的右子树
- 30做了60的左子树
- 60结点成了这棵树新的根结点
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
Node* parentParent = parent->_parent;//先保存下来,因为后面会改变这个,就找不到最开始的父节点了
subR->_left = parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
//作为子树的一部分
if (parentParent->_left == parent)
{
parentParent->_left = subR;
}
else
{
parentParent->_right = subR;
}
subR->_parent = parentParent;
}
//平衡因子
subR->_bf = parent->_bf = 0;
}
3.1.3 先左单旋再右单旋
新节点插入较高左子树的右侧
将双旋变成单旋后再旋转,即:先对30进行左单旋,然后再对90进行右单旋,旋转完成后再考虑平衡因子的更新。看是看上图也可以发现,在b插入一个新节点和在c插入一个新节点的最终结果是不一样的,所以还需要分类讨论。
为了能够更好的理解这段代码,需要在借助下面的这个图。
- 先把30结点作为parent结点,进行一个左单旋操作
- 再把90作为parent结点,进行一个右单旋
- 其实大致的思想和单旋基本一致
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = parent->_left->_right;
int bf = subLR->_bf;
RotateL(subL);//这里的左旋和右旋操作会最终改变平衡因子,所以前面进行保存,以便讨论
RotateR(parent);
//如果在b或者c插入节点,导致b或者c的高度增加了1,就会引起双旋并且要分开讨论,b插入或者c插入,树的平衡因子更新是要分开看待的
if (bf == 1) // 说明subLR是右树插入(看图解释就是c处)
{
subLR->_bf = 0;//(类比于图中,60这个结点平衡因子肯定是0)
parent->_bf = 0;
subL->_bf = -1;
}
else if (bf == -1) // 说明subLR是左树插入(看图解释就是b处)
{
subLR->_bf = 0;
parent->_bf = 1;
subL->_bf = 0;
}
else if(bf == 0)//bf == 0说明subLR是新增结点
{
subL->_bf = subLR->_bf = parent->_bf = 0;
}
else
{
assert(false);
}
}
3.1.4 先右单旋再左单旋
新节点插入较高右子树的左侧
将双旋变成单旋后再旋转,即:先对30进行右单旋,然后再对90进行左单旋,旋转完成后再考虑平衡因子的更新。看是看上图也可以发现,在b插入一个新节点和在c插入一个新节点的最终结果是不一样的,所以还需要分类讨论。
为了能够更好的理解这段代码,需要在借助下面的这个图。
- 先把30结点作为parent结点,进行一个右单旋操作
- 再把90作为parent结点,进行一个左单旋
- 其实大致的思想和单旋基本一致
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);//这里的左旋和右旋操作会最终改变平衡因子,所以前面进行保存,以便讨论
RotateL(parent);
if (bf == 1) // 说明subRL是右树插入(看图解释就是c处)
{
subRL->_bf = 0;
subR->_bf = 0;
parent->_bf = -1;
}
else if (bf == -1) // 说明subRL是左树插入(看图解释就是b处)
{
subRL->_bf = 0;
subR->_bf = 1;
parent->_bf = 0;
}
else if(bf == 0) //bf == 0说明subLR是新增结点
{
subRL->_bf = subR->_bf = parent->_bf = 0;
}
else
{
assert(false);
}
}
3.1.5 完整的AVL树插入代码
pair<Node*, bool> Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
return make_pair(_root, true);
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
//那么说明你插入的值比根节点的值要小,往左边去插入
if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_kv.first < kv.first) //往右边插入
{
parent = cur;
cur = cur->_right;
}
else
{
//此时说明此时说明两个值相等了,那就不能进行插入了
return make_pair(cur, false);
}
}
cur = new Node(kv);
//此时说明已经找到了位置,还需要进行插入
if (parent->_kv.first < kv.first)
{
//说明此时应该链接在父节点的右边
parent->_right = cur;
cur->_parent = parent;
}
else
{
parent->_left = cur;
cur->_parent = parent;
}
Node* newnode = cur;
//在这里插入成功了,但是他会影响祖先的平衡因子,所以这里也是和二叉搜索树的不同和关键所在
//1.更新平衡因子
while (parent)
{
if (cur == parent->_right)
{
parent->_bf++;
}
else
{
parent->_bf--;
}
if (parent->_bf == 0)
{
break;//说明parent所在子树的高度不变(没有更新前,parent->_bf是1或者-1,又一遍高,现在变成了0,说明把矮的
//那边给填上了),不会再对上层路径上的结点构成影响,所以更新结束。
}
else if (abs(parent->_bf) == 1)
{
//说明parent所在的子树的高度改变了,对上一层是有影响的,需要继续向上更新
cur = parent;
parent = parent->_parent;//往上跳一层
}
else if (abs(parent->_bf) == 2)
{
//说明parent所在的子树已经不再平衡了,需要旋转处理
//此时就是旋转的问题
//1.右单旋
//2.左单旋
//3.先左单旋再右单旋
//4.先右单旋再左单旋
if (parent->_bf == -2)
{
if (cur->_bf == -1)
{
RotateR(parent);
}
else //cur->_bf == 1
{
RotateLR(parent);
}
}
else
{
if (cur->_bf == 1)
{
RotateL(parent);
}
else //cur->_bf == -1
{
RotateRL(parent);
}
}
break;//旋转完成之后,就已经恢复了原来的平衡二叉树特性
}
else
{
//就不可能走到这里,如果走到了,说明在平衡因子为2的时候,就没有正确的处理
assert(false);
}
}
//这里的cur可能会改变,因为会向上进行更新,所以可以早早的保存下来
make_pair(newnode, true);
}
总结:
假如以parentParent为根的子树不平衡,即parentParent的平衡因子为2或者-2,分以下情况考虑
-
parentParent的平衡因子为2,说明parent的右子树高,设parentParent的右子树的根为SubR
- 当subR的平衡因子为1时,执行左单旋
- 当subR的平衡因子为-1时,执行右左双旋 -
parentParent的平衡因子为-2,说明parentParent的左子树高,设parentParent的左子树的根为subL
- 当subL的平衡因子为-1是,执行右单旋
- 当subL的平衡因子为1时,执行左右双旋
旋转完成后,原parentParent为根的子树个高度降低,已经平衡,不需要再向上更新。
4. AVL树的验证
AVL树是在二叉搜索树的基础上加入了平衡性的限制,因此要验证AVL树,可以分两步:
- 验证其为二叉搜索树
如果中序遍历可得到一个有序的序列,就说明为二叉搜索树 - 验证其为平衡树
- 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
- 节点的平衡因子是否计算正确
int Height(Node* root)
{
if (root == nullptr)
{
return 0;
}
//这里可以使用一个max函数,来求二者之间的较大值
return Height(root->_left) > Height(root->_right) ? Height(root->_left) + 1 : Height(root->_right) + 1;
}
bool _IsBalance(Node* root)
{
if (root == nullptr)
{
return true;
}
int leftHeight = Height(root->_left);
int rightHeight = Height(root->_right);
if (rightHeight - leftHeight != root->_bf)
{
cout << "平衡因子异常:" << endl;
}
return abs(rightHeight - leftHeight) < 2
&& _IsBalance(root->_left)
&& _IsBalance(root->_right);
//第一个是当前树的,但是他满足还不足以,还需要他们的子树也都满足平衡二叉树的特性才可以
}
bool IsBalance()
{
return _IsBalance(_root);
}
void _Inorder(Node*& root)
{
if (root == nullptr)
return;
_Inorder(root->_left);
cout << root->_kv.first << " ";
_Inorder(root->_right);
}
void Inorder()
{
_Inorder(_root);
}
#include"AVLTree.h"
int main()
{
//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
AVLTree<int, int> t;
for (auto e : a)
{
t.Insert(make_pair(e, e));
}
t.Inorder();
cout << endl;
cout<<t.IsBalance()<<endl;
}
5. AVL树的性能
AVL树是一棵绝对平衡的二叉搜索树,其要求每个节点的左右子树高度差的绝对值都不超过1,这样可以保证查询时高效的时间复杂度,即log(N)(以2为底) 。但是如果要对AVL树做一些结构修改的操作,性能非常低下,比如:插入时要维护其绝对平衡,旋转的次数比较多,更差的是在删除时,有可能一直要让旋转持续到根的位置。因此:如果需要一种查询高效且有序的数据结构,而且数据的个数为静态的(即不会改变),可以考虑AVL树,但一个结构经常修改,就不太适合。