概念
AVL树是一种自平衡二叉搜索树(BST),被命名为Adelson-Velskii和Landis树,以它们的发明者们的名字命名。AVL树通过在插入和删除操作后进行自旋操作来保持树的平衡,以确保树的高度始终保持在O(logN)。这样可以减少树的平均长度,提高搜索效率。
一颗二叉搜索树,如果每个根节点的左右子树的高度差的绝对值不超过1,那么这就是一颗AVL树
一般的二叉搜索树在插入新节点以及删除节点时,都有可能会破坏树的平衡,所以AVL树需要对插入以及删除接口做修改,每次插入删除时,都要检测一下当前的树时候符合AVL树,如果不符合,要做出相应的调整措施。
实现
插入
限制于AVL树的要求,每个根节点的左右子树高度差绝对值不超过1,我们在此处为AVL树增加一个成员_bf
,称为平衡因子(balance factor),其值为左右子树高度的差值,当这个差值的绝对值>=2,就说明这个节点的左右子树不平衡,那么我们就要使用相应的手段调整这棵树。在此处,本博客的平衡因子为 右子树高度 - 左子树高度,这样顺序没有严格要求。
AVL树节点类:
template<class K, class V>
struct AVLTreeNode
{
AVLTreeNode* _left;
AVLTreeNode* _right;
AVLTreeNode* _parent;
int _bf;
pair<K, V> _kv;
AVLTreeNode(const pair<K, V>& kv)
: _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _bf(0)
, _kv(kv)
{}
};
首先,由于平衡因子的限制,我们的AVL树任何一颗高为h + 1的子树只有可能会出现以下三种情况:
三种情况分别是:
- 两棵子树等高的情况,在任意一边插入
- 两棵子树不等高的情况,在矮的子树插入
- 两颗子树不等高的情况,在高的子树插入
情况一:_bf = 0
变成_bf = 1
或_bf = -1
,不影响AVL结构,影响父节点
情况二:_bf = 1
或_bf = -1
变成_bf = 0
,不影响AVL结构,不影响父节点
情况三:_bf = 1
或_bf = -1
变成_bf = 2
或_bf = -2
,影响AVL结构,立刻调整子树
那么我们先写出当前的代码逻辑,既然要插入,那么就要先找到合适的位置插入,代码如下:
bool Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
}
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
cur = new Node(kv);
if (parent->_kv.first > kv.first)
parent->_left = cur;
else
parent->_right = cur;
cur->_parent = parent;
//调整平衡
//......
//......
//......
return true;
}
既然我们在parent
处插入了节点,那么我们第一步就是更新parent
的平衡因子:
如果
cur
是parent
的左子树,那么平衡因子-1
如果cur
是parent
的右子树,那么平衡因子+1
更新完平衡因子后,就要判断属于三种情况的哪一种
代码实现:
情况一:
_bf = 0
变成_bf = 1
或_bf = -1
,不影响AVL结构,影响父节点
其不会影响自身的AVL结构,所以不用对自生做操作,但是由于其高度增加了,所以有可能会影响其父节点,那么此时我们就要去看看父节点是否平衡。而对于其父节点而言,也必然会是三种情况之一,所以我们只需要一个循环即可:
while (parent)
{
if (cur == parent->_left)
parent->_bf--;
else
parent->_bf++;
if (parent->_bf == 0)
{
//情况二
}
else if (parent->_bf == 1 || parent->_bf == -1)
{
cur = cur->_parent;
parent = parent->_parent;
}
else if (parent->_bf == 2 || parent->_bf == -2)
{
//情况三
}
else
{
assert(false);
}
}
情况二:
_bf = 1
或_bf = -1
变成_bf = 0
,不影响AVL结构,不影响父节点
因为其不会影响自己以外的节点,也没有破坏平衡,所以直接跳出while
循环,啥也不用做。
while (parent)
{
if (cur == parent->_left)
parent->_bf--;
else
parent->_bf++;
if (parent->_bf == 0)
{
break;
}
else if (parent->_bf == 1 || parent->_bf == -1)
{
cur = cur->_parent;
parent = parent->_parent;
}
else if (parent->_bf == 2 || parent->_bf == -2)
{
//情况三
//调整平衡
//......
//......
//......
}
else
{
assert(false);
}
}
第三种情况如下: 也就是子树不等高的情况下,在高子树插入节点,导致原本高的子树更高了,破坏了平衡。
以左侧为例,我们将高度为h
的子树拆分出来,其一定是是以下情况之一:
对于左侧情况,叫做LL失衡
(L表示left),对于右侧情况,叫做LR失衡
(R表示right)。
与LL失衡
对应的是RR失衡
,我们先解决这两种情况的失衡:
右单旋
我们先看到右单旋的示意图,再做讲解:
插入前后高度不变,不会影响父节点,直接跳出循环。
//右单旋
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 (parent == _root)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
ppNode->_left = subL;
else
ppNode->_right = subL;
subL->_parent = ppNode;
}
parent->_bf = 0;
subL->_bf = 0;
}
代码解析:
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
此代码完成了parent
与subLR
之间的链接,要注意的是,subLR
有可能是空指针,比如这样:
所以在访问 subLR->_parent
之前,需要先确保subRL
不是空指针。
subL->_right = parent;
Node* ppNode = parent->_parent;
parent->_parent = subL;
这一段代码完成了subL
与parent
之间的链接,由于parent
可能还有父节点,所以我们先把parent
的父节点ppNode
保存下来,后续完成subL
与ppNode
链接。
if (parent == _root)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
ppNode->_left = subL;
else
ppNode->_right = subL;
subL->_parent = ppNode;
}
这一段代码,完成了ppNode与subL之间的链接,但是如果parent原先是_root节点的话,那么ppNode就是空指针,此时直接把_root更新为subR即可。
如果parent不是_root,那么直接进行链接即可,由于不确定parent原先是ppNode的左子树还是右子树,所以链接前需要检测一下。
parent->_bf = 0;
subL->_bf = 0;
这段代码则是完成平衡因子的更新,左单旋后,parent
与subL
的平衡因子都变成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;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (ppNode->_left == parent)
ppNode->_left = subR;
else
ppNode->_right = subR;
subR->_parent = ppNode;
}
parent->_bf = 0;
subR->_bf = 0;
}
我们现在还有两种失衡没有解决:
左右双旋
当AVL树出现LR失衡
,我们就需要用到左右双旋
,LR失衡
又分为以下两种情况:
在subLR
的左子树插入后旋转: 在
subLR
的右子树插入后旋转:
现在我们来完成代码:
//左右双旋
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
//更新平衡因子
}
在
subLR
的左子树插入后旋转:在
subLR
的右子树插入后旋转:当
subLR
就是新插入的节点:
可以看到,整体上有三种情况,三种情况对应的平衡因子最后都不同,所以我们要分类讨论。三种情况的区别在于:第一种情况subLR
的平衡因子为-1
,第二种情况subLR
的平衡因子为1
,第三种情况subLR
的平衡因子为0
。
这样我们就可以写出以下代码:
//左右双旋
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(parent->_left);
RotateR(parent);
if (bf == -1)
{
subLR->_bf = 0;
subL->_bf = 0;
parent->_bf = 1;
}
else if (bf == 1)
{
subLR->_bf = 0;
subL->_bf = -1;
parent->_bf = 0;
}
else if (bf == 0)
{
subLR->_bf = 0;
subL->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
右左双旋
代码如下:
//右左双旋
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == -1)
{
subR->_bf = 1;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = -1;
}
else if (bf == 0)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
总代码展示
由于插入操作已经可以很好的理解AVL控制平衡的手段了,此处就不讲解erase操作了,总代码如下:
AVLTree.h
:
template<class K,class V>
struct AVLTreeNode
{
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)
{}
};
template<class K, class V>
class AVLTree
{
typedef AVLTreeNode<K, V> Node;
public:
bool Insert(const pair<K,V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
else
{
//已存在,不能插入
return false;
}
}
//已找到插入的位置,插入更新
cur = new Node(kv);
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
//更新平衡因子,看是否调整
while (parent)
{
if (cur == parent->_left)
{
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 && cur->_bf == -1)
{
RotateR(parent);
}
else if (parent->_bf == 2 && cur->_bf == 1)
{
RotateL(parent);
}
else if (parent->_bf == 2 && cur->_bf == -1)
{
RotateRL(parent);
}
else if (parent->_bf == -2 && cur->_bf == 1)
{
RotateLR(parent);
}
break;
}
else
{
// 理论而言不可能出现这个情况
assert(false);
}
}
return true;
}
//右单旋
void RotateR(Node* parent)
{
//左左偏移
//右单旋
Node* subL = parent->_left;//不用cur的原因是只需要传递一个参数parent就可以解耦出一个右单旋函数
Node* subLR = subL->_right;
//调整爷爷节点和孙子节点的指向关系
parent->_left = subLR;
if (subLR)
{
//如果subLR不为空,则调整其父亲
subLR->_parent = parent;
}
subL->_right = parent;
//将parent的parent的子节点指向subL
Node* ppNode = parent->_parent;
parent->_parent = subL;
if (parent == _root)
{
_root = subL;
_root->_parent = nullptr;
}
else
{
//调整parent的parent的指向
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else
{
ppNode->_right = subL;
}
subL->_parent = ppNode;
}
//调节后的parent和subL的平衡因子都为0
parent->_bf = subL->_bf = 0;
}
//左单旋
void RotateL(Node* parent)
{
//右右偏移
//左单旋
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if(subRL)
subRL->_parent = parent;
Node* ppNode = parent->_parent;
subR->_left = parent;
parent->_parent = subR;
if (parent == _root)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
//判断parent是ppNode的左节点还是右节点
if (ppNode->_left == parent)
{
ppNode->_left = subR;
subR->_parent = ppNode;
}
else
{
ppNode->_right = subR;
subR->_parent = ppNode;
}
}
parent->_bf = subR->_bf = 0;
}
void RotateRL(Node*parent)
{
//右左双旋
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(subR);
RotateL(parent);
subRL->_bf = 0;
if (bf == 1)
{
subR->_bf = 0;
parent->_bf = -1;
}
else if (bf == -1)
{
parent->_bf = 0;
subR->_bf = 1;
}
else
{
parent->_bf = 0;
subR->_bf = 0;
}
}
void RotateLR(Node*parent)
{
//左右双旋
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(parent->_left);
RotateR(parent);
if (bf == -1)
{
subLR->_bf = 0;
subL->_bf = 0;
parent->_bf = 1;
}
else if (bf == 1)
{
subLR->_bf = 0;
subL->_bf = -1;
parent->_bf = 0;
}
else if (bf == 0)
{
subLR->_bf = 0;
subL->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < key)
{
cur = cur->_right;
}
else if (cur->_kv.first > key)
{
cur = cur->_left;
}
else
{
return cur;
}
}
return nullptr;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
bool IsBalance()
{
return _IsBalance(_root);
}
int Height()
{
return _Height(_root);
}
int Size()
{
return _Size(_root);
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}
int _Size(Node* root)
{
return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
}
int _Height(Node* root)
{
if (root == nullptr)
return 0;
return max(_Height(root->_left), _Height(root->_right)) + 1;
}
bool _IsBalance(Node* root)
{
if (root == nullptr)
{
return true;
}
int leftHeight = _Height(root->_left);
int rightHeight = _Height(root->_right);
// 不平衡
if (abs(leftHeight - rightHeight) >= 2)
{
cout << root->_kv.first << endl;
return false;
}
// 顺便检查一下平衡因子是否正确
if (rightHeight - leftHeight != root->_bf)
{
cout << root->_kv.first << endl;
return false;
}
return _IsBalance(root->_left)
&& _IsBalance(root->_right);
}
private:
Node* _root = nullptr;
};