一，什么是AVL树
之前我们学习了二叉搜索树，但是有时候因为节点插入的问题，可能会退化为单支树，这样会导致查找效率变得底下如顺序表。
因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：
当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度
这种树就是AVL树.
二，AVL树的特性
AVL树满足两个条件：
- 它的左右子树都是AVL树
- 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
平衡因子=右子树高度-左子树高度
如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在
O
(
l
o
g
2
n
)
O(log_2 n)
O(log2n)，搜索时间复杂度O(
l
o
g
2
n
log_2 n
log2n)
三，模拟实现
1. 基本框架
AVL树是一种平衡二叉树，其内部存储的是pair键值对，我们模拟实现的时候直接用pair来存储即可。
我们先来写AVL的节点定义：
每个节点都要有一个平衡因子用来保证其AVL树特性
template<class K,class V>
struct AVLTreeNode {
typedef AVLTreeNode<K, V> Node;
AVLTreeNode(const pair<K,V> &kv)
:_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_bf(0)
,_kv(kv)
{}
Node* _left;
Node* _right;
Node* _parent;//记录当前节点的父亲
int _bf;//记录节点的平衡因子
pair<K, V> _kv;//保存记录的key,val
};
然后我们来写AVL的框架：
template<class K,class V>
class AVLTree {
typedef AVLTreeNode<K, V> Node;
public:
//...
private:
Node* _root = nullptr;
};
2. 插入（不带旋转）
下面我们来实现AVL树的插入：
插入分为两步：
- 按照二叉搜索树那样插入节点
- 调整平衡因子
插入节点的部分和二叉搜索树的代码一样，主要是修改平衡因子的部分
当插入新节点后，这个新节点的双亲节点的平衡因子会发生变化:
1.新插入的节点cur在其双亲节点parent的左孩子时，parent的平衡因子-1
2. 新插入的节点在parent的右孩子时，parent的平衡因子+1
代码如下：
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 (kv.first > cur->_kv.first) {
parent = cur;
cur = cur->_right;
}
else if (kv.first < cur->_kv.first) {
parent = cur;
cur = cur->_left;
}
else {
return false;
}
}
//找到了插入位置
cur = new Node(kv);
if (kv.first > parent->_kv.first) {
parent->_right = cur;
}
else {
parent->_left = cur;
}
cur->_parent = parent;
//修改平衡因子
while (parent) {
if (cur == parent->_left) {//如果加在左边，则父节点的平衡因子--
parent->_bf--;
}
else {
parent->_bf++;//右边则++
}
//调整平衡因子
//...
}
return true;
}
修改后这里有三种情况：
- 如果pParent的平衡因子为0，说明插入之前pParent的平衡因子为正负1，插入后被调整成0，此时满足AVL树的性质，插入成功
- 如果pParent的平衡因子为正负1，说明插入前pParent的平衡因子一定为0，插入后被更新成正负1，此时以pParent为根的树的高度增加，需要继续向上更新
- 如果pParent的平衡因子为正负2，则pParent的平衡因子违反平衡树的性质，需要对其进行旋转处理
我们先来说前两种情况，第三种我们在旋转中讲解
第一种情况：
修改后parent的平衡因子为0，这里就不用再进行调整了
第二种情况：
修改后平衡因子为1，则以parent为根的这颗树的高度发生了变化，则要继续向上调整平衡因子
代码：
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 (kv.first > cur->_kv.first) {
parent = cur;
cur = cur->_right;
}
else if (kv.first < cur->_kv.first) {
parent = cur;
cur = cur->_left;
}
else {
return false;
}
}
//找到了插入位置
cur = new Node(kv);
if (kv.first > parent->_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 = cur->_parent;
parent = parent->_parent;
}
else if (parent->_bf == 2 || parent->_bf == -2) {
//旋转
}
else {
assert(false);//说明插入之前就有问题
}
}
return true;
}
2. AVL树的旋转
上面的两种情况，更新parent的平衡因子后AVL树的特性还保持着，但是第三种情况更新后，双亲的平衡因子为2/-2，破坏了平衡二叉搜索树的特性，所以就要进行以parent为根的树的旋转
AVL树的旋转也分为四种情况
1. 新节点插入较高左子树的左侧：右单旋
2. 新节点插入较高右子树的右侧：左单旋
3. 新节点插入较高左子树的右侧—左右双旋：先左单旋再右单旋
4. 新节点插入较高右子树的左侧—右左双旋：先右单旋再左单旋
下面我们来依次解释：
右单旋：
右单旋是新插入的节点在左子树中，使其整棵树右高左低，所以要旋转右子树来降低高度差使这棵树变得平衡
具体过程看下图：
这里我们来看一下具体当各子树高度的情况：
下面我们来编写一下右单璇的代码：
首先我们定义两个节点用来标记当前需要旋转的节点。
对于右单旋，我们找当前parent的左孩子 subL 和该左孩子的右孩子 subLR
然后我们在旋转时还要注意一下：
（1） 30这个节点的右子树可能存在也可能不存在
不存在时我们就不能直接将subL的parent指针直接指向60
void RotateR(Node* parent) {//右单旋
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR) {//当subLR存在时，subLR的parent才指向parent
subLR->_parent = parent;
}
//...
}
（2） 60这个节点可能是根也可能不为根。
不为根时，我们还需要一个 ppnode 节点来标记parent的双亲节点，用来将新的’根’节点去链接到原来的树上。
void RotateR(Node* parent) {//右单旋
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR) {//当subLR存在时，subLR的parent才指向parent
subLR->_parent = parent;
}
if (parent == _root) {//如果p是根,则subL更新为根
_root = subL;
subL->_parent = nullptr;
}
else {//将旋转后的子树的根节点链接到原来的树上
if (ppnode->_left == parent) {
ppnode->_left = subL;
}
else {
ppnode->_right = subL;
}
subL->_parent = ppnode;
}
//...
}
最后一步就是修改平衡因子，旋转后的节点不用再调整，因为旋转后子树的两端高度都相等，达到平衡。
void RotateR(Node* parent) {//右单旋
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR) {//当subLR存在时，subLR的parent才指向parent
subLR->_parent = parent;
}
subL->_right = parent;
Node* ppnode = parent->_parent;//保存p的parent指向
parent->_parent = subL;
if (parent == _root) {//如果p是根,则subL更新为根
_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;
}
现在来看左单旋：
左单旋和右单旋相反，左边高右边低，所以进行左单旋来降低高度差
这里的情况都和右单旋转相反，我们直接上代码：
void RotateL(Node* parent) {//左单旋
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL) {//当subRL存在时，subRL的parent才指向parent
subRL->_parent = parent;
}
subR->_left = parent;
Node* ppnode = parent->_parent;//保存p的parent指向
parent->_parent = subR;
if (parent == _root) {//如果p是根,则subR更新为根
_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;
}
我们现在来看左右双旋，先左单旋再右单旋
这里的左右双旋其实就是相当右单旋的那种场景下，将b子树拆分成两颗子树，再将新增节点加在拆分后的子树上
我们以加在左子树为例讲解：
对新增节点后的树进行旋转，先以subL为根进行左旋，
再对parent为根进行右旋
加在右子树的过程和这个相反，希望大家可以自己去推导…
知道了大概的过程，我们现在来写代码：
和单旋一样，我们定义变量来协助我们旋转
void RotateRL(Node* parent) {//双旋（先左单旋，再右单旋）
Node* subL = parent->_left;
Node* subLR = subL->_right;
//..
}
这里需要注意：新增节点所加的位置有三种情况
（1） 加在拆分后的左子树上
（2） 加在拆分后的右子树上
（3） 上图的60这个位置本身是空的
那么我们如何区分这三种情况呢，
我们可以用subLR的平衡因子来区分，subLR的因子为-1时，说明左高，则加在了左子树上，为1时，说明右高，则加在了右子树，为0时说明这个位置原来是空的。
void RotateLR(Node* parent) {
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(subL);
RotateR(parent);
subLR->_bf = 0;
if (bf == -1) {
parent->_bf = 1;
subL->_bf = 0;
}else if (bf == 1) {
parent->_bf = 0;
subL->_bf = -1;
}
else if (bf == 0) {
parent->_bf = 0;
subL->_bf = 0;
}
else {
assert(false);
}
subLR->_bf = 0;
}
右左双旋
右左双旋和左右双旋相反，各位老铁可以参考左右双旋来自己去画出图来理解
代码：
void RotateRL(Node* parent) {//双旋（先右单旋，再左单旋）
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;//以subRL的因子为标准判断所加的子树的位置
RotateR(subR);
RotateL(parent);
//修改平衡因子
//增加节点后有三种情况
subRL->_bf = 0;
if (bf == -1) {//加在左子树上
parent->_bf = 0;
subR->_bf = 1;
}
else if (bf == 1) {
parent->_bf = -1;
subR->_bf = 0;
}
else if (bf == 0) {
parent->_bf = 0;
subR->_bf = 0;
}
else {
assert(false);
}
}
3. AVL树的验证
AVL的插入讲完了，我们来看看如何证明咋们模拟实现的就是AVL树
一棵树如果是AVL树，那么首先它是一个二叉搜索树，其次他的每个子树的高度差不能超过1
这里我们做了一点小优化，我们在判断时先传入高度，判断高度差时类似于后序遍历的方式，从下往上去计算高度差
代码如下：
bool IsBalance() {
int height = 0;
return _IsBalance(_root, height);
}
bool _IsBalance(Node* root,int &height) {
if (root == nullptr) {
height = 0;
return true;
}
int leftHeight = 0, rightHeight = 0;
if (!_IsBalance(root->_left, leftHeight) || !_IsBalance(root->_right, rightHeight)) {
return false;
}
if (abs(rightHeight - leftHeight) >= 2) {
cout <<root->_kv.first<< "不平衡" << endl;
return false;
}
if (rightHeight - leftHeight != root->_bf) {
cout << root->_kv.first << "平衡因子异常" << endl;
return false;
}
height = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
return true;
}
四，总结
我们今天终于讲完了AVL树，我们的C++部分也开始上了难度，希望大家可以跟上我们的讲解，下一节我们要来开始手撕红黑树！！！
在此之前我们要熟悉前面的二叉搜索树和AVL树的内容，希望大家都能学好C++。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
