目录
AVL树是一种自平衡二叉查找树，也被称为高度平衡树。它具有以下特点：
- 它本身是一棵二叉搜索树，即每个结点包含一个关键字和两个子结点，且满足左子树中所有关键字小于该结点的关键字，右子树中所有关键字大于该结点的关键字。
- AVL树带有平衡条件，即每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。为了保持这种平衡，可能需要通过一次或多次树旋转来重新平衡，这可能需要对树进行调整。
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;
}AVL树是一种绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1。这样的平衡条件使得AVL树在查询时的性能高效且稳定。在AVL树中，任何节点的两个子树的高度差都不超过1，因此，在执行查询操作时，最坏的情况就是需要遍历log(N)层节点，其中N是树中节点的数量，因此查询效率非常高。
然而，如果需要对AVL树进行结构修改操作，比如插入或删除节点，维持其绝对平衡性的同时会导致性能降低。在插入节点时，需要维护其平衡性，这可能会导致旋转的次数增加。在最差的情况下，旋转次数可能达到O(log(N))，这会显著影响到插入操作的性能。
在删除节点时，可能需要执行多次旋转操作来重新平衡树。在最差的情况下，删除操作可能需要O(log(N))的时间复杂度，因为需要一直旋转到根节点。因此，如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的（即不会改变），可以考虑AVL树。然而，如果数据经常需要修改，那么AVL树可能就不是最佳选择了。
总的来说，AVL树在查询性能上表现出色，但如果需要经常进行结构修改操作，其性能就可能会变得较差。