🌟个人主页：第七序章****
🌈专栏系列：C＋＋****
目录
[🌙2. 1、平衡因子（_bf）](#🌙2. 1、平衡因子（_bf）)
[☀️三、 AVL树查找](#☀️三、 AVL树查找)
[☀️四、 AVL树的插入](#☀️四、 AVL树的插入)
[☀️五、 AVL树的旋转](#☀️五、 AVL树的旋转)
[🌙3.1 选用抽象图探讨AVL旋转](#🌙3.1 选用抽象图探讨AVL旋转)
[🌙3.2 单旋问题](#🌙3.2 单旋问题)
[🌙3.3 双旋问题](#🌙3.3 双旋问题)
[🌙6.2、 验证其为平衡树](#🌙6.2、 验证其为平衡树)
[🌙6.3、 验证用例：](#🌙6.3、 验证用例：)
❄️前言：
☀️一、AVL树的概念
二叉搜索树虽然可以缩短查找的效率，但是如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。
因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了 一种解决上述问题的方法：
当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度，
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
- 它的左右子树都是AVL树
- 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
- 平衡因子并不是必须，只是他的一种实现方式
如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在logn,搜索时间复杂度O(logn)
平衡因子计算:
- 平衡因子 = 右子树高度 - 左子树高度
☀️二、AVL树实现
AVL树节点的定义通常包含以下几个关键部分：
🌙2.1、基本元素
在调整失衡的AVL树时，我们需要频繁的访问父节点，所以在AVL树中我们需要使用三叉链，因此AVL树的节点除了包含左右子节点的指针，还需要一个指向父节点的指针。
- _left：指向节点的左子节点的指针
- _right：指向节点的右子节点的指针
- _parent：指向节点的父节点的指针
- _kv：一个结构体或配对（pair），包含节点的键值（key）和值（value）。这取决于AVL树的具体用途，可能只包含键或包含键值对。
🌙2. 1、平衡因子（_bf）
🥭一个整数，表示节点左子树和右子树的高度差。AVL树的性质要求任何节点的平衡因子的绝对值不超过1（-1, 0, 1）
🥭如果左子树比右子树高一层，那么平衡因子就为-1；如果左右子树一样高，平衡因子就为0；
🥭如果右子树比左子树高一层，那么平衡因子就为1，这三种情况下AVL树的性质都没有被打破。
🥭按照这个规则，如果平衡因子为-2、2或其他值，则说明左右子树已经失衡，性质被打破。
🌙2.3、构造函数
- 初始化一个新节点时，通常需要一个构造函数，它接受一个键值对（或仅键），并设置节点的左子节点、右子节点、父节点和平衡因子（初始化为0）
另外需要说明一下，本文中，我们使用key/value模型的AVL树
🌙2.4、AVL节点定义：
cpp
template<class K, class V>
struct AVLTreeNode
{
pair<K, V> _kv;//第一个数据存储key，第二个数据存储value
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
int _bf; // balance factor，平衡因子，值为右子树与左子树高度差，右边插入就加一，左边插入减一
AVLTreeNode(const pair<K, V>& kv)
:_kv(kv)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _bf(0) //新节点左右都为空，平衡因子为0
{}
};注意：
可能有些同学对pair没有了解，这里简单介绍一下，pair可以将两个数据组成一组元素，因此对于key/value模型这种需要用到两个数据为一组的元素时就可以使用，内部的成员变量为first和second，主要使用方法如下：
cpp
pair<T1, T2> p1(v1, v2); //输入两个数据创建pair类型变量
make_pair(v1, v2); //输入两个数据通过函数创建pair类型变量
p1.first //访问p1的第一个数据
p1.second //访问p1的第二个数据☀️三、 AVL树查找
cpp
Node* Find(const K& key)
{
//按照搜索树
Node* cur = _root;
while (cur)
{
if (key > cur->_kv.first)
{
cur = cur->_right;
}
else if (key < cur->_kv.first)
{
cur = cur->_left;
}
else
{
//返回当前节点的指针
return cur;
}
}
//防止意外发生。
return nullptr;
}本质上来说AVL树属于二叉搜索树，关于cur->_kv.first是cur通过指针去访问Node类中类型为pair<K, V>对象的_kv。通过set与map简单学习。可以得知pair内部实现逻辑，_这里的kv.first中first是K类型的对象。同时AVL也是二叉树搜索树，查找逻辑当然是使用二叉搜索树的逻辑。
☀️四、 AVL树的插入
AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：
- 按照二叉搜索树的方式插入新节点
- 调整节点的平衡因子
在我们进行插入操作之前，我们先定义一个AVL树的类
AVL树定义：
cpp
template<class K,class V>
class AVLTree
{
typedef AVLTreeNode<K, V> Node;
public:
// 其他未实现的成员函数
private:
Node* _root = nullptr;
};cur插入后，parent的平衡因子一定需要调整
在插入之前，parent的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：
- 如果cur插入到parent的左侧，只需给parent的平衡因子-1即可
- 如果cur插入到parent的右侧，只需给parent的平衡因子+1即可
插入后，parent的平衡因子可能有三种情况：0，正负1， 正负2🥭如果parent的平衡因子为0，说明插入之前parent的平衡因子为正负1，插入后被调整
成0，此时满足AVL树的性质，插入成功
🥭如果parent的平衡因子为正负1，说明插入前pParent的平衡因子一定为0，插入后被更
新成正负1，此时以parent为根的树的高度增加，需要继续向上更新
🥭如果parent的平衡因子为正负2，则parent的平衡因子违反平衡树的性质，需要对其进
行旋转处理
AVL树的插入操作类似于我们之前二叉搜索树的插入，只不过AVL树的插入操作涉及到旋转操作，我们先演示一下它的全部代码
cpp
bool Insert(const pair<K, V>& kv) //和之前的二叉平衡树插入类似
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
//第一步先找到cur应该插入的位置
Node* parent = nullptr, * cur = _root;
while (cur)
{
parent = cur; //保留其父节点
if (cur->_kv.first < kv.first)
{
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
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) //和书上相反，因为书上是把左侧插入节点平衡因子增大，这里左侧插入减小
{
// 不平衡了，旋转处理，cur为插入节点的父节点，paernt为cur的父节点
if (parent->_bf == 2 && cur->_bf == 1) //RR型，在子树根节点右子树的右子树插入节点
{ //逆时针左旋转
RotateL(parent);
}
else if (parent->_bf == -2 && cur->_bf == -1)//LL型，在子树根节点左子树上的左子树插入节点，
{ //顺时针右旋转
RotateR(parent);
}
else if (parent->_bf == 2 && cur->_bf == -1) //RL型，在子树根节点右子树上的左子树插入节点
{//先顺时针右旋变成RR型，再逆时针左旋，最后就是原子树根节点右子树上左子树作为子树根节点。
RotateRL(parent);
}
else if (parent->_bf == -2 && cur->_bf == 1) //LR型，在子树根节点左子树上的右子树插入节点
{ //先逆时针左旋变成LL型，再顺时针右旋，最后就是原子树根节点左子树上的右子树作为子树根节点。
RotateLR(parent);
}
break;
}
else
{
assert(false);
}
}
return true;
}☀️五、 AVL树的旋转
如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，
使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：
这里可以将前面两种归为单旋进行处理，而后面两种需要通过双旋进行处理。
提前说明:一个AVL树有多个AVL树或者说一个复杂的AVL树是由许多个简单的AVL树进行组合而成的。那么如果插入一个节点导致AVL树失去平衡，这里AVL树指以插入节点的父亲节点为根节点的子AVL树。遵守一个有问题解决问题，如果只是这一课AVL树有问题，就解决这颗AVL树，正常的AVL树我们是不要去过多的进行处理。
根据说明，如果将一整棵AVL树全部拆分进行研究，不同节点插入的位置很多选择，情况有很多种，难以全部罗列出来，而且没有必要，如果将一颗有问题AVL树治好，就可以将任何一颗AVL树治好，所以这边采用使用抽象图进行分析。
🌙3.1 、选用抽象图探讨AVL旋转
其中使用a、b、c子AVL树及其高度设置为h
🌙3.2、单旋问题
使用单旋场景 :parent->_bf == 2 && cur->_bf == 1或者parent->_bf == -2 && cur->_bf == -1
⭐右单旋
场景:parent->_ bf == -2 && cur->_bf == -1
具体解析旋转步骤:
目前AVL树是平衡的，当插入新节点30到左子树中，左子树高度加一层，导致以60为根的子AVL树失去平衡。为了使得平衡，意味着节点60的右子树也需要增加一层，那么将60节点成为30节点的左孩子，同时原本30节点的左孩子和60节点成为30节点的左孩子的高度相同，那么将原本30节点的左孩子成为60节点有孩子。这里保证了30节点原本左孩子一定是小于60节点的。更新节点的平衡因子即可，简单概况就是30 < b子树 < 60 < c子树
旋转过程中，有以下几点情况需要考虑:
- 30节点的右孩子可能存在，也可能不存在
- 60可能是根节点，也可能是子树
- 如果是根节点，旋转完成后，要更新根节点
- 如果是子树，可能是某个节点的左子树，也可能是右子树
AVL树右单旋代码示例：
cpp
void RotateR(Node* parent) //顺时针右单旋，arent为根，subL为根左子树，subLR为根左子树的右子树
{ //subLR变成parene的左边，parent变成subL的右边，subL变成这颗子树的根
Node* subL = parent->_left, *subLR = subL->_right;
Node* parentParent = parent->_parent;
//改变parent的左子树
parent->_left = subLR;
if (subLR != nullptr) //避免为空
subLR->_parent = parent;
//改变parent的父节点
subL->_right = parent;
parent->_parent = subL;
//改变子树根节点，调整subL为子树根节点
if (parentParent == nullptr){//第一种情况：parent为根节点
_root = subL;
subL->_parent = nullptr;
}
else{//第二种情况：parent不为根节点
if (parentParent->_left == parent) parentParent->_left = subL;
else parentParent->_right = subL;
subL->_parent = parentParent; //记得更新子树根节点的父节点
}
parent->_bf = subL->_bf = 0; //更新平衡因子
}通过旋转使得不平衡AVL树得到调整，这里不需要考虑向上更新平衡因子。从抽象图中可以得出旋转后结论，直接使用结论修改平衡因子就行。
⭐左单旋
场景:parent->_ bf == 2 && cur->_bf == 1
这里和右单旋是差不多的，具体流程可以去看上述和代码分析
AVL树左单旋代码示例：
cpp
void RotateL(Node* parent) //逆时针左单旋，parent为子树根节点，subR为根右子树，subRL为根右子树的左子树
{ //subRL变成parene的右边，parent变成subR的左边，subR变成这颗子树的根
Node* subR = parent->_right, *subRL = subR->_left;
Node* parentParent = parent->_parent;
//改变parentt的右子树
parent->_right = subRL;
if(subRL != nullptr) //避免为空
subRL->_parent = parent;
//改变parent的父节点
subR->_left = parent;
parent->_parent = subR;
//改变子树根节点，调整subR为子树根节点
if (parentParent == nullptr) { //第一种情况：parent为根节点
_root = subR;
subR->_parent = nullptr;
}
else{ //第二种情况，parent不是根节点
if (parentParent->_left == parent) parentParent->_left = subR;
else parentParent->_right = subR;
subR->_parent = parentParent;//记得更新子树根节点的父节点
}
parent->_bf = subR->_bf = 0;//更新平衡因子
}🌙3.3、双旋问题
如果出现了这种**if (parent->_bf == 2 || cur->_bf == -1), if (parent->_bf == -2 || cur->_bf == 1)**普通单旋是不能解决问题的，需要使用到双旋。
如果使用单旋的话是没有多大作用的，做无用功。我们使用单旋处理的情况是一边独高 ，而不是那边高，这边高。对此可以先对内部旋转变成单独一边高，再使用单旋进行调整AVL树。
⭐左右双旋
场景:parent->_bf == -2 && cur->_bf == 1
这里是将双旋变成单旋后再旋转，先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。
根据结论修改AVL树节点平衡因子
通过图中对于不同情况的分析，对于修改平衡因子的结果是根据SubLR平衡因子特殊值决定的。b、c分别给谁，会影响平衡因子的分配。
AVL树左右双旋代码示例：
cpp
void RotateLR(Node* parent) //先以根节点的左子树进行右旋，再对根节点进行左旋
{
Node* subL = parent->_left, *subLR = subL->_right;
int bf = subLR->_bf;
RotateL(parent->_left);
RotateR(parent);
if (bf == 0) { //其本身就是新增节点，h = 0
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1) { //在subL的右子树插入节点
subL->_bf = -1;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1){ //在subL的左子树插入节点
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 1;
}
else assert(false);
}⭐右左双旋
场景:parent->_bf == 2 && cur->_bf == -1
这里还是需要根据60这块的平衡因子去判断的，b c分别给谁，会影响平衡因子的分配。左边新增两次旋转给到右边，右边新增两次旋转给到左边，通过结论最后修改平衡因子。
cpp
void RotateRL(Node* parent) //先以根节点的右子树进行右旋，再对根节点进行左旋
{
Node* subR = parent->_right, *subRL = subR->_left;
int bf = subRL->_bf; //g
RotateR(parent->_right);
RotateL(parent);
//更新平衡因子
if (bf == 0) { //其本身就是新增节点, h = 0
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1) { //在subRL上的右子树插入节点
subR->_bf = 1;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1) { //在subRL的左子树上插入节点
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = -1;
}
else assert(false);
}总结：
假如以parent为根的子树不平衡，即parent的平衡因子为2或者-2，分以下情况考虑
parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR
🥭当subR的平衡因子为1时，执行左单旋
🥭当subR的平衡因子为-1时，执行右左双旋
parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL
🥭当subL的平衡因子为-1是，执行右单旋
🥭当subL的平衡因子为1时，执行左右双旋
旋转完成后，原parent为根的子树个高度降低，已经平衡，不需要再向上更新
☀️六、AVL树的验证
AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：
🌙6.1、验证其为二叉搜索树
如果中序遍历可得到一个有序的序列，就说明为二叉搜索树
代码示例：
cpp
void InOrder()
{
_InOrder(_root);
cout << endl;
}
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << " ";
_InOrder(root->_right);
}这里将中序遍历实现逻辑封装到私有成员函数中隐藏它的具体实现细节，使得外部用户无法直接访问该函数，提高了代码的安全性和可维护性，符合面向对象编程的封装性原则。这里外部访问中序遍历接口，只是传递了节点指针的副本，而不修改任何节指针的实际值。
🌙6.2、 验证其为平衡树
- 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
- 节点的平衡因子是否计算正确
代码示例：
cpp
bool IsBalance()
{
return _IsBalance(_root);
}
private:
bool _IsBalance(Node* root)
{
if (root == nullptr) return true;
int leftHeight = _Height(root->_left), rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return false;
}
if (diff != root->_bf)
{
cout << root->_kv.first << "平衡因子异常" << endl;
return false;
}
return _IsBalance(root->_left) && _IsBalance(root->_right);
}
size_t _Height(Node* root)
{
if (root == nullptr) return 0;
size_t leftHeight = _Height(root->_left);
size_t rightHeight = _Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}🌙6.3、 验证用例：
cpp
void TestAVLTree()
{
AVLTree<int, int> t;
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
for (auto e : a)
{
t.Insert({ e, e });
//cout << e << "->" << t.IsBalance() << endl;
}
t.InOrder();
cout << endl;
if (t.IsBalance()) printf("AVL树建立成功\n");
else printf("AVL树建立失败\n");
}☀️七、AVL树的性能和完整代码
AVL树追求的是严格平衡，因此可以保证查找时高效的时间复杂度O(logN)，但是如果我们需要频繁的对其进行旋转来维护平衡，一定程度上会影响效率，尤其是删除节点时的最差情况下我们可能需要一路旋转到根的位置。
相对于AVL树的严格平衡，红黑树则追求一种相对平衡，因此会略胜一筹，后面的文章中会对红黑树进行讲解。
| 缺陷 | 原因 |
|---|---|
| 插入操作复杂 | 为了保持树的平衡，每次插入或删除节点时，AVL 树可能需要进行多次旋转操作。具体来说，插入一个节点可能需要单旋转或双旋转来重新平衡树结构，而删除节点后可能需要从被删除节点到根节点这条路径上所有节点的平衡，旋转的量级最坏情况下为 O (logN)。这增加了操作的复杂性并可能影响性能。 |
| 维护成本高 | 由于 AVL 树要求每个节点的左右子树高度差不超过 1，因此需要频繁地检查和调整树的结构。这种严格的平衡要求导致了相对较高的维护成本，特别是在频繁进行插入和删除操作的情况下。 |
| 空间开销较大 | 虽然 AVL 树在查找效率上具有优势，但由于其需要频繁地进行旋转操作以维持平衡，这可能导致额外的空间开销。尤其是在处理大量数据时，这种开销可能会更加明显。 |
| 不适用于所有场景 | AVL 树适用于查找操作远多于插入和删除操作的场景。如果在一个应用中插入和删除操作也非常频繁，那么 AVL 树可能不是最优选择，因为每次插入和删除都需要进行平衡调整，这会影响性能。 |
AVL树的完整代码如下：
cpp
#pragma once
#include <iostream>
#include <assert.h>
#include <cmath>
using namespace std;
template<class K, class V>
struct AVLTreeNode
{
pair<K, V> _kv;//第一个数据存储key，第二个数据存储value
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
int _bf; // balance factor，平衡因子，值为右子树与左子树高度差，右边插入就加一，左边插入减一
AVLTreeNode(const pair<K, V>& kv)
:_kv(kv)
, _left(nullptr)
, _right(nullptr)
, _parent(nullptr)
, _bf(0) //新节点左右都为空，平衡因子为0
{}
};
template<class K, class V>
class AVLTree
{
typedef AVLTreeNode<K, V> Node;
public:
//默认成员函数
AVLTree() = default; //构造
AVLTree(const AVLTree<K, V>& t) //拷贝构造
{
_root = Copy(t._root);
}
AVLTree<K, V>& operator=(AVLTree<K, V> t) //赋值构造
{
swap(_root, t._root);
return *this;
}
~AVLTree() //析构
{
Destroy(_root);
_root = nullptr;
}
bool Insert(const pair<K, V>& kv) //和之前的二叉平衡树插入类似
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
//第一步先找到cur应该插入的位置
Node* parent = nullptr, * cur = _root;
while (cur)
{
parent = cur; //保留其父节点
if (cur->_kv.first < kv.first)
{
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
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) //和书上相反，因为书上是把左侧插入节点平衡因子增大，这里左侧插入减小
{
// 不平衡了，旋转处理，cur为插入节点的父节点，paernt为cur的父节点
if (parent->_bf == 2 && cur->_bf == 1) //RR型，在子树根节点右子树的右子树插入节点
{ //逆时针左旋转
RotateL(parent);
}
else if (parent->_bf == -2 && cur->_bf == -1)//LL型，在子树根节点左子树上的左子树插入节点，
{ //顺时针右旋转
RotateR(parent);
}
else if (parent->_bf == 2 && cur->_bf == -1) //RL型，在子树根节点右子树上的左子树插入节点
{//先顺时针右旋变成RR型，再逆时针左旋，最后就是原子树根节点右子树上左子树作为子树根节点。
RotateRL(parent);
}
else if (parent->_bf == -2 && cur->_bf == 1) //LR型，在子树根节点左子树上的右子树插入节点
{ //先逆时针左旋变成LL型，再顺时针右旋，最后就是原子树根节点左子树上的右子树作为子树根节点。
RotateLR(parent);
}
break;
}
else
{
assert(false);
}
}
return true;
}
Node* Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key < key){
cur = cur->_right;
}
else if (cur->_key > key){
cur = cur->_left;
}
else{
return cur;
}
}
return nullptr;
}
Node* LeftMost()
{
if (_root == nullptr) return nullptr;
Node* cur = _root;
while (cur->_left) cur = cur->_left;
return cur;
}
Node* RightMost()
{
if (_root == nullptr) return nullptr;
Node* cur = _root;
while (cur->_right) cur = cur->_right;
return cur;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
bool IsBalance()
{
return _IsBalance(_root);
}
private:
bool _IsBalance(Node* root)
{
if (root == nullptr) return true;
int leftHeight = _Height(root->_left), rightHeight = _Height(root->_right);
int diff = rightHeight - leftHeight;
if (abs(diff) >= 2)
{
cout << root->_kv.first << "高度差异常" << endl;
return false;
}
if (diff != root->_bf)
{
cout << root->_kv.first << "平衡因子异常" << endl;
return false;
}
return _IsBalance(root->_left) && _IsBalance(root->_right);
}
size_t _Height(Node* root)
{
if (root == nullptr) return 0;
size_t leftHeight = _Height(root->_left);
size_t rightHeight = _Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}
void RotateL(Node* parent) //逆时针左单旋，parent为子树根节点，subR为根右子树，subRL为根右子树的左子树
{ //subRL变成parene的右边，parent变成subR的左边，subR变成这颗子树的根
Node* subR = parent->_right, *subRL = subR->_left;
Node* parentParent = parent->_parent;
//改变parentt的右子树
parent->_right = subRL;
if(subRL != nullptr) //避免为空
subRL->_parent = parent;
//改变parent的父节点
subR->_left = parent;
parent->_parent = subR;
//改变子树根节点，调整subR为子树根节点
if (parentParent == nullptr) { //第一种情况：parent为根节点
_root = subR;
subR->_parent = nullptr;
}
else{ //第二种情况，parent不是根节点
if (parentParent->_left == parent) parentParent->_left = subR;
else parentParent->_right = subR;
subR->_parent = parentParent;//记得更新子树根节点的父节点
}
parent->_bf = subR->_bf = 0;//更新平衡因子
}
void RotateR(Node* parent) //顺时针右单旋，arent为根，subL为根左子树，subLR为根左子树的右子树
{ //subLR变成parene的左边，parent变成subL的右边，subL变成这颗子树的根
Node* subL = parent->_left, *subLR = subL->_right;
Node* parentParent = parent->_parent;
//改变parent的左子树
parent->_left = subLR;
if (subLR != nullptr) //避免为空
subLR->_parent = parent;
//改变parent的父节点
subL->_right = parent;
parent->_parent = subL;
//改变子树根节点，调整subL为子树根节点
if (parentParent == nullptr){//第一种情况：parent为根节点
_root = subL;
subL->_parent = nullptr;
}
else{//第二种情况：parent不为根节点
if (parentParent->_left == parent) parentParent->_left = subL;
else parentParent->_right = subL;
subL->_parent = parentParent; //记得更新子树根节点的父节点
}
parent->_bf = subL->_bf = 0; //更新平衡因子
}
void RotateRL(Node* parent) //先以根节点的右子树进行右旋，再对根节点进行左旋
{
Node* subR = parent->_right, *subRL = subR->_left;
int bf = subRL->_bf; //g
RotateR(parent->_right);
RotateL(parent);
//更新平衡因子
if (bf == 0) { //其本身就是新增节点, h = 0
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1) { //在subRL上的右子树插入节点
subR->_bf = 1;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1) { //在subRL的左子树上插入节点
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = -1;
}
else assert(false);
}
void RotateLR(Node* parent) //先以根节点的左子树进行右旋，再对根节点进行左旋
{
Node* subL = parent->_left, *subLR = subL->_right;
int bf = subLR->_bf;
RotateL(parent->_left);
RotateR(parent);
if (bf == 0) { //其本身就是新增节点，h = 0
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1) { //在subL的右子树插入节点
subL->_bf = -1;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == -1){ //在subL的左子树插入节点
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 1;
}
else assert(false);
}
void Destroy(Node* root)
{
if (root == nullptr)return;
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
Node* Copy(Node* root)
{
if (root == nullptr)
return nullptr;
Node* newRoot = new Node(root->_key, root->_value);
newRoot->_left = Copy(root->_left);
newRoot->_right = Copy(root->_right);
return newRoot;
}
private:
Node* _root = nullptr;
};
void TestAVLTree()
{
AVLTree<int, int> t;
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
for (auto e : a)
{
t.Insert({ e, e });
//cout << e << "->" << t.IsBalance() << endl;
}
t.InOrder();
cout << endl;
printf("最左边节点为：%d，最右边节点为：%d\n", t.LeftMost()->_kv.first, t.RightMost()->_kv.first);
if (t.IsBalance()) printf("AVL树建立成功\n");
else printf("AVL树建立失败\n");
}
补充调式小技巧:
当我们实现插入节点出现出现平衡因子异常时：
cpp
void TestAVLTree1()
{
//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
AVLTree<int, int> t1;
for (auto e : a)
{
/*if (e == 4)
{
int i = 0;
}*/
// 1、先看是插入谁导致出现的问题
// 2、打条件断点，画出插入前的树
// 3、单步跟踪，对比图一一分析细节原因
t1.Insert({e,e});
cout <<"Insert:"<< e<<"->"<< t1.IsBalance() << endl;
}
t1.InOrder();
cout << t1.IsBalance() << endl;
}☀️八、AVL树的删除
因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置 ，这里调正平衡因子的逻辑就需要反过来，同时参考下二叉搜索树的删除操作。
☀️九、思维导图
🌻共勉:
以上就是本篇博客的所有内容，如果你觉得这篇博客对你有帮助的话，可以点赞收藏关注支持一波~~🥝
