AVL树是计算机科学中一种自平衡的二叉搜索树,旨在保持树的高度尽可能低,以提高查找、插入和删除操作的效率。它是由苏联数学家 Adelson-Velsky 和 Landis 于1962年发明的,因此得名为 AVL 树。
1. AVL树的定义与概念
1.1 定义
AVL树是一种满足以下条件的二叉搜索树:
- 二叉搜索树的性质:对每个节点,其左子树中的所有节点值小于该节点值,右子树中的所有节点值大于该节点值。
- 平衡因子:对每个节点,左右子树的高度差(称为平衡因子)最多为 1,即 平衡因子=左子树高度−右子树高度
- 自平衡性:在每次插入或删除节点后,AVL树会通过旋转操作重新平衡,以确保树的平衡因子始终在 [−1,1][-1, 1][−1,1] 之间。
1.2 关键性质
- 高度受限:在有 n 个节点的情况下,AVL树的高度始终保持在 log2 n 的量级,因此查找、插入和删除操作的时间复杂度是 O(log n)。
- 旋转操作:在插入或删除导致平衡因子超出范围时,通过旋转操作恢复平衡:
- 单旋转:左旋或右旋
- 双旋转:先左后右旋,或先右后左旋
2. AVL树的结构
template<class T, class V>
struct AVLTreeNode
{
pair<K, V> _kv;
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
int _bf;
AVLTreeNode(const pair<K, V>& kv)
:_kv(kv)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _bf(0);
{}
};
template<class K, class V>
class AVLTree
{
typedef AVLTreeNode<K, V> Node;
public:
//...
private:
Node* _root = nullptr;
};
3. AVL树的插入
3.1 节点插入
1. 插入一个值的第一步是按照二叉搜索树的规则进行插入。新的节点被添加到树中作为叶子节点。
2.插入新节点后,树的高度可能会发生变化,但这种变化只会影响插入节点的祖先节点的高度。因此,需要从新增节点沿路径向根节点更新每个祖先节点的平衡因子。最坏情况下需要更新到根节点,有时在中间某个节点即可停止更新,具体情况取决于树的结构和平衡因子的变化。
3.1 如果在更新平衡因子的过程中未发现任何节点的平衡因子超出范围(即不超过1或-1),说明树仍然平衡,插入操作结束。
3.2 如果在更新平衡因子的过程中发现某个节点的平衡因子不在范围内(即等于2或-2),说明该节点所在的子树失衡。通过旋转操作调整子树恢复平衡,同时降低子树的高度,使其不再影响上一层。旋转后,插入操作结束。
3.2 平衡因子的更新
更新原则
- 平衡因子的定义:平衡因子 = 右子树高度 - 左子树高度
- 更新条件:只有子树高度发生变化时,当前节点的平衡因子才会受到影响。
- 节点插入对平衡因子的影响:
- 如果新节点插入到父节点的右子树中,父节点的平衡因子增加1。
- 如果新节点插入到父节点的左子树中,父节点的平衡因子减少1。
- 更新路径:父节点所在子树的高度变化将决定是否需要继续向上更新。
更新停止条件
- 平衡因子更新后等于0:
当父节点的平衡因子从 -1 变为 0 或从 1 变为 0 时,表示插入的节点被添加到了较低的子树,使两边高度相等,父节点所在子树的高度未发生变化,因此可以停止更新。 - 平衡因子更新后等于1或-1:
当父节点的平衡因子从 0 变为 1 或从 0 变为 -1 时,表示插入的节点导致父节点所在子树一边高、一边低。虽然父节点的子树高度增加了,但仍满足平衡条件,因此需要继续向上更新。 - 平衡因子更新后等于2或-2:
当父节点的平衡因子从 1 变为 2 或从 -1 变为 -2 时,表示插入的节点使父节点所在子树失衡,需要通过旋转操作恢复平衡。旋转的目标是:- 使子树恢复平衡。
- 降低子树的高度,使其恢复到插入节点之前的高度,从而无需继续向上更新。
3.3 代码实现
bool Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
}
//找到预插入节点
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 false;
}
}
//插入节点
cur = new Node(kv);
//插入节点小于当前节点则插入左子树
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
}
//插入节点大于当前节点则插入右子树
else
{
parent->_left = cur;
}
cur->_parent = parent;
//更新平衡因子
while (cur)
{
//插入左子树平衡因子减一
if (cur->_kv.first < parent->_kv.first)
{
parent->_bf--;
}
else if (cur->_kv.first > parent->_kv.first)
{
parent->_bf++;
}
//平衡因子为0时停止更新
if (parent->_bf == 0) break;
//为1时继续向上更新
else if (parent->_bf == 1 || parent->_bf == -1)
{
cur = parent;
parent = cur->_parent;
}
//为-2时需要旋转
else if (parent->_bf == 2 || parent->_bf == -2)
{
break;
}
else
{
assert(false);
}
}
return true;
}
4. AVL树的旋转
4.1 AVL树旋转的原则
1. 旋转的目标
- 恢复平衡:将失衡节点及其子树调整为平衡状态,使所有节点的平衡因子重新满足 -1、0 或 1。
- 高度优化:旋转后,受影响子树的高度恢复到操作前的高度,以避免继续向上影响祖先节点。
- 保持二叉搜索树性质:调整后,树仍然是二叉搜索树,左子树的值小于根节点,右子树的值大于根节点。
2. 失衡类型
失衡的节点根据其平衡因子的变化,可以分为以下四种情况:
- 左子树过高(LL型):
插入点位于失衡节点的左子树的左子树上。
解决方法:右旋(Single Right Rotation)。 - 右子树过高(RR型):
插入点位于失衡节点的右子树的右子树上。
解决方法:左旋(Single Left Rotation)。 - 左右失衡(LR型):
插入点位于失衡节点的左子树的右子树上。
解决方法:先左旋后右旋(Double Rotation: Left-Right)。 - 右左失衡(RL型):
插入点位于失衡节点的右子树的左子树上。
解决方法:先右旋后左旋(Double Rotation: Right-Left)。
3. 旋转操作的具体原则
-
右旋(Single Right Rotation):
- 适用于 LL型 失衡。
- 原理:将失衡节点的左子节点提升为新的根节点,同时将原根节点作为左子节点的右子树。
- 高度变化:子树高度减少1。
-
左旋(Single Left Rotation):
- 适用于 RR型 失衡。
- 原理:将失衡节点的右子节点提升为新的根节点,同时将原根节点作为右子节点的左子树。
- 高度变化:子树高度减少1。
-
左右旋(Left-Right Rotation):
- 适用于 LR型 失衡。
- 原理:对失衡节点的左子节点先进行一次左旋,变成 LL型 后,再对失衡节点进行右旋。
- 高度变化:子树高度减少1。
-
右左旋(Right-Left Rotation):
- 适用于 RL型 失衡。
- 原理:对失衡节点的右子节点先进行一次右旋,变成 RR型 后,再对失衡节点进行左旋。
- 高度变化:子树高度减少1。
4.2 代码实现
(1)右单旋
//右单旋
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
//改变指向
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
subL->_right = parent;
parent->_parent = subL;
//如果parent是整棵树的根
if (parent->_parent == nullptr)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (parent == parent->_parent->_left)
{
parent->_parent->_left = subL;
}
else if (parent == parent->_parent->_right)
{
parent->_parent->_right = subL;
}
subL->_parent = parent->_parent;
}
parent->_bf = subL->_bf = 0;
}
(2)左单旋
//左单旋
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subL->_right;
//改变指向
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
parent->_parent = subR;
//如果parent是整棵树的根
if (parent->_parent == nullptr)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parent == parent->_parent->_left)
{
parent->_parent->_left = subR;
}
else if (parent == parent->_parent->_right)
{
parent->_parent->_right = subR;
}
subR->_parent = parent->_parent;
}
parent->_bf = subR->_bf = 0;
}
(3)左右双旋
//左右双旋
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
//左旋
RotateL(subL);
//右旋
RotateR(parent);
if (bf == 0)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 1;
}
else if (bf == 1)
{
subL->_bf = -1;
subLR->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
(4)右左双旋
//右左双旋
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == 0)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = -1;
}
else if (bf == -1)
{
subR->_bf = 1;
subRL->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
5. AVL树的查找
//查找
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_bf.first > key)
{
cur = cur->_left;
}
else if (cur->_bf.first < key)
{
cur = cur->_right
}
else {
return cur;
}
}
return nullptr;
}
6. 完整代码
template<class T, class V>
struct AVLTreeNode
{
pair<K, V> _kv;
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
int _bf;
AVLTreeNode(const pair<K, V>& kv)
:_kv(kv)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _bf(0);
{}
};
template<class T, class V>
class AVLTree
{
typedef AVLTreeNode<K, V> Node;
public:
bool Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
}
//找到预插入节点
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 false;
}
}
//插入节点
cur = new Node(kv);
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
//更新平衡因子
while (cur)
{
if (cur->_kv.first < parent->_kv.first)
{
parent->_bf--;
}
else if (cur->_kv.first > parent->_kv.first)
{
parent->_bf++;
}
//平衡因子为0时停止更新
if (parent->_bf == 0) break;
//为1时继续向上更新
else if (parent->_bf == 1 || parent->_bf == -1)
{
cur = parent;
parent = cur->_parent;
}
//为-2时需要旋转
else if (parent->_bf == 2 || parent->_bf == -2)
{
break;
}
else
{
assert(false);
}
}
return true;
}
//右单旋
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
//改变指向
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
subL->_right = parent;
parent->_parent = subL;
//如果parent是整棵树的根
if (parent->_parent == nullptr)
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (parent == parent->_parent->_left)
{
parent->_parent->_left = subL;
}
else if (parent == parent->_parent->_right)
{
parent->_parent->_right = subL;
}
subL->_parent = parent->_parent;
}
parent->_bf = subL->_bf = 0;
}
//左单旋
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subL->_right;
//改变指向
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
subR->_left = parent;
parent->_parent = subR;
//如果parent是整棵树的根
if (parent->_parent == nullptr)
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parent == parent->_parent->_left)
{
parent->_parent->_left = subR;
}
else if (parent == parent->_parent->_right)
{
parent->_parent->_right = subR;
}
subR->_parent = parent->_parent;
}
parent->_bf = subR->_bf = 0;
}
//左右双旋
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
//左旋
RotateL(subL);
//右旋
RotateR(parent);
if (bf == 0)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 1;
}
else if (bf == 1)
{
subL->_bf = -1;
subLR->_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 == 0)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = -1;
}
else if (bf == -1)
{
subR->_bf = 1;
subRL->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
//查找
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_bf.first > key)
{
cur = cur->_left;
}
else if (cur->_bf.first < key)
{
cur = cur->_right
}
else {
return cur;
}
}
return nullptr;
}
private:
Node* _root = nullptr;
};