目录
1.什么是AVL树?
AVL树是一种自平衡二叉查找树,也被称为高度平衡树。它具有以下特点:
- 它本身是一棵二叉搜索树,即每个结点包含一个关键字和两个子结点,且满足左子树中所有关键字小于该结点的关键字,右子树中所有关键字大于该结点的关键字。
- AVL树带有平衡条件,即每个结点的左右子树的高度之差的绝对值(平衡因子)最多为1。为了保持这种平衡,可能需要通过一次或多次树旋转来重新平衡,这可能需要对树进行调整。
2.AVL树插入的模拟实现
①节点定义
template<class K, class V>
struct AVLTreeNode
{
AVLTreeNode(const pair<K, V>& kv)
:_kv(kv)
,_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_bf(0)
{}
pair<K, V> _kv;
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
int _bf; //平衡因子
};
因为在使用过程中可能会频繁使用到父节点,因此我们将其设计为三叉链,且在这里我们设计一个平衡因子(注:在AVL树中可能没有平衡因子,在这里引入平衡因子只是为了方便我们理解),规定一个初始节点的平衡因子为0,当它的左子树中出现新节点时平衡因子就--,右子树中出现新节点时平衡因子就++,当平衡因子==2或者==-2时,此时我们就认为当前节点往下的树已经失衡,需要对其作出调整(各式各样的旋转)
②插入
bool Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
// 寻找要插入的位置
while (cur)
{
if (kv.first < cur->_kv.first)
{
parent = cur;
cur = cur->_left;
}
else if (kv.first > cur->_kv.first)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
// 到此处cur已经指向了应该插入的位置,
// 然后判断应该插入到parent的哪边
cur = new Node(kv);
if (kv.first > cur->_kv.first)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
// 插入完成后要更改平衡因子
// 从父节点向上更新一直更新到平衡因子为0(已平衡)
// 或者更新到平衡因子为2或-2(已失衡)
// 或者更新到根节点的父节点为止
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)
{
// 此时当前节点已失衡,需要通过旋转来调整
// ......(在下方结合图片具体分析)
}
else
{
assert();
}
}
return true;
}
③旋转
根据插入位置的不同,可以具体地将它们大致分为四类。它们分别有对应的旋转策略,在这里我们使用先特殊后推广到一般的方法来解释
⑴右单旋
此情况适用于新节点插入较高左子树的左侧时,抽象图如下
当h==0时,示例图如下
当h==1时,示例图如下
接下来推广到一般,示例图如下
不难看出,右单旋操作的关键是将当前节点(即5)的右边赋给父节点(即10)的左边,然后将当前节点(即5)的右边指向父节点,再增添一些细节后可以得到如下右单旋代码
void RotateR(Node* parent)
{
Node* cur = parent->_left; // 记录当前节点
Node* curright = cur->_right; // 记录当前节点的右节点
// 如果当前节点的右节点为空说明是h为0的情况
// 不为空时就要进行节点间的连接
if (curright)
{
curright->_parent = parent;
}
parent->_left = curright;
cur->_right = parent;
// 此时需要确定parent是否属于子树
if (parent == _root)
{
_root = cur;
cur->_parent = nullptr;
}
else // 此时parent以下的节点属于子树
{
cur->_parent = parent->_parent;
// 确认parent与其父节点间的关系
// 然后将cur与parent的父节点连接起来
if (parent->_parent->_left == parent)
{
parent->_parent->_left = cur;
}
else
{
parent->_parent->_right = cur;
}
}
parent->_parent = cur;
// 在进行右单旋后,当前节点与父节点的平衡因子均变为0
cur->_bf = parent->_bf = 0;
}
⑵左单旋
此情况适用于新节点插入较高右子树的右侧,抽象图如下
其具体情况与右单旋类似,这里就不过多赘述,直接给出代码
void RotateL(Node* parent)
{
Node* cur = parent->_right; // 记录当前节点
Node* curleft = cur->_left; // 记录当前节点的左节点
// 如果当前节点的左节点为空说明是h为0的情况
// 不为空时就要进行节点间的连接
if (curleft)
{
curleft->_parent = parent;
}
parent->_right = curleft;
cur->_left = parent;
// 此时需要确定parent是否属于子树
if (parent == _root)
{
_root = cur;
cur->_parent = nullptr;
}
else // 此时parent以下的节点属于子树
{
cur->_parent = parent->_parent;
// 确认parent与其父节点间的关系
// 然后将cur与parent的父节点连接起来
if (parent->_parent->_left == parent)
{
parent->_parent->_left = cur;
}
else
{
parent->_parent->_right = cur;
}
}
parent->_parent = cur;
// 在进行左单旋后,当前节点与父节点的平衡因子均变为0
cur->_bf = parent->_bf = 0;
}
⑶双旋(右左旋)
此情况适用于新节点插入较高左子树的右侧,抽象图如下
在此我们先以左边的插入情况举例
当h==0时,示例图如下
当h==1时,示例图如下
接下来推广到一般,示例图如下
接下来再让我们看看右边的情况
当h==0时,示例图如下
当h==1时,示例图如下
接下来推广到一般,示例图如下
结合上述几幅图像来看,从结果上来看,最终的结果是15节点的右边赋给了20节点的左边,15节点的左边边赋给了10节点的右边;此外,对于平衡因子来说,当h==0时,三个节点的平衡因子均被更新为0,而h!=0时,三个节点的平衡因子分为2种情况,当插入在15节点的左边时,三个节点的平衡因子分别被更新为0,0,1,当插入在15节点的右边时,三个节点的平衡因子分别被更新为0,0,-1。通过复用左单旋与右单旋的代码可以得到如下代码
void RotateRL(Node* parent)
{
Node* cur = parent->_right;
Node* curleft = cur->_left;
int bf = curleft->_bf;
RotateR(cur);
RotateL(parent);
if (bf == 0) // h==0的情况
{
parent->_bf = 0;
cur->_bf = 0;
curleft->_bf = 0;
}
else if (bf == 1) //新节点插入到右侧的情况
{
parent->_bf = -1;
cur->_bf = 0;
curleft->_bf = 0;
}
else if (bf == -1)//新节点插入到左侧的情况
{
cur->_bf = 1;
parent->_bf = 0;
curleft->_bf = 0;
}
else // 出现其他情况时报错
{
assert();
}
}
⑷双旋(左右旋)
此情况适用于新节点插入较高左子树的右侧,具体抽象图如下
这里与上面的右左旋大同小异,因此在这里只画出两种情况的一般示例图与h==0的示例图
当h==0时,示例图如下
当新节点插入在7的左侧时,一般示例图如下
当新节点插入在7的右侧时,一般示例图如下
根据结果我们发现它的结果与右左旋类似,因此我们只需对代码作一定的修改即可,代码如下
void RotateLR(Node* parent)
{
Node* cur = parent->_left;
Node* curright = cur->_right;
int bf = curright->_bf;
RotateL(cur);
RotateR(parent);
if (bf == 0) // h==0的情况
{
parent->_bf = 0;
cur->_bf = 0;
curright->_bf = 0;
}
else if (bf == 1) //新节点插入到右侧的情况
{
parent->_bf = 0;
cur->_bf = -1;
curleft->_bf = 0;
}
else if (bf == -1)//新节点插入到左侧的情况
{
cur->_bf = 0;
parent->_bf = 1;
curleft->_bf = 0;
}
else // 出现其他情况时报错
{
assert();
}
}
⑸完整的插入代码
bool Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
// 寻找要插入的位置
while (cur)
{
if (kv.first < cur->_kv.first)
{
parent = cur;
cur = cur->_left;
}
else if (kv.first > cur->_kv.first)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
// 到此处cur已经指向了应该插入的位置,
// 然后判断应该插入到parent的哪边
cur = new Node(kv);
if (kv.first > cur->_kv.first)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
// 插入完成后要更改平衡因子
// 从父节点向上更新一直更新到平衡因子为0(已平衡)
// 或者更新到平衡因子为2或-2(已失衡)
// 或者更新到根节点的父节点为止
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)
{
RotateL(parent);
}
else if (parent->_bf == -2 && cur->_bf == -1)
{
RotateR(parent);
}
else if (parent->_bf == 2 && cur->_bf == -1)
{
RotateRL(parent);
}
else if (parent->_bf == -2 && cur->_bf == 1)
{
RotateLR(parent);
}
// 插入完成后结束插入
break;
}
else
{
assert();
}
}
return true;
}
3.AVL树的性能分析
AVL树是一种绝对平衡的二叉搜索树,其要求每个节点的左右子树高度差的绝对值都不超过1。这样的平衡条件使得AVL树在查询时的性能高效且稳定。在AVL树中,任何节点的两个子树的高度差都不超过1,因此,在执行查询操作时,最坏的情况就是需要遍历log(N)层节点,其中N是树中节点的数量,因此查询效率非常高。
然而,如果需要对AVL树进行结构修改操作,比如插入或删除节点,维持其绝对平衡性的同时会导致性能降低。在插入节点时,需要维护其平衡性,这可能会导致旋转的次数增加。在最差的情况下,旋转次数可能达到O(log(N)),这会显著影响到插入操作的性能。
在删除节点时,可能需要执行多次旋转操作来重新平衡树。在最差的情况下,删除操作可能需要O(log(N))的时间复杂度,因为需要一直旋转到根节点。因此,如果需要一种查询高效且有序的数据结构,而且数据的个数为静态的(即不会改变),可以考虑AVL树。然而,如果数据经常需要修改,那么AVL树可能就不是最佳选择了。
总的来说,AVL树在查询性能上表现出色,但如果需要经常进行结构修改操作,其性能就可能会变得较差。