C++《AVL树》

🕗 发布于 2025-01-22 05:39 c++ 数据结构

在之前的学习当中我们已经了解了二叉搜索树，并且我们知道二叉搜索树的查找效率是无法满足我们的要求，当二叉树为左或者右斜树查找的效率就很低下了，那么这本篇当中我们就要来学习对二叉搜索树进行优化的二叉树——AVL树。在此会先来了解AVL树是什么，之后再学习AVL树的结构特点，最后会试着来实现AVL树的结构。在AVL树当中各种旋转是较难理解的，需要我们静下心来理解，一起加油吧！！！

1.AVL树的概念

AVL树是最先发明的自平衡⼆叉查找树，AVL是⼀颗空树，或者具备下列性质的二叉搜索树：
它的左右子树都是AVL树，且左右子树的高度差的绝对值不超过1。AVL树是⼀颗高度平衡搜索二叉树，通过控制高度差去控制平衡。

AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis是两个前苏联的科学家，他们在1962年的论文《An algorithm for the organization of information》中发表了它。

在此在AVL树实现这里我们引入一个平衡因子(balance factor)的概念，每个结点都有⼀个平衡因子，任何结点的平衡因子等于右子树的高度减去左子树的高度，也就是说任何结点的平衡因子等于0/1/-1，AVL树并不是必须要平衡因子，但是有了平衡因子可以更方便我们去进⾏观察和控制树是否平衡，就像⼀个风向标⼀样。

这时你可能有疑惑了，为什么AVL树是高度平衡搜索⼆叉树，要求高度差不超过1，而不是高度差是0呢？0不是更好的平衡吗？

这时就可以来画画图，其实不是不想这样设计，而是有些情况是做不到高度差是0的。就例如当节点个数是2或者4的时候节点的最大高度差最好就是1，而到不了0

虽然AVL树无法做到保证所有子树没有高度差，但每个子树高度差最大就为2，这就使得AVL树整体结点数量和分布和完全二叉树类似，高度以控制在 logN ，那么增删查改的效率也可以控制在 O(logN) ，相比二叉搜索树有了本质的提升。

2.AVL树的实现

在了解了AVL树的概念以及结构特特点之后接下来我们就试着来实现AVL树，在此和二叉搜索类似在AVL树当中我们依旧会实现插入和查找的功能，但在此AVL树中的删除功能就没有实现，原因是在AVL树当中删除的功能也是在二叉搜索树的删除基础上进行改进的，但结合了旋转之后就较为复杂，如果你学有余力可以试着自己实现看看。

在此我们将会在头文件AVLTree当中实现AVL树的各个结构，之后在test.cpp内测试实现的AVL树是否满足我们的要求

2.1 AVL树节点结构实现

在AVL树当中每个节点内的信息是和二叉搜索树类似，只不过增加两个变量bf和_parent分别表示节点内的平衡因子和指向其父节点的指针，其他的和二叉搜索树类型。

实现的代码如下所示：

template<class T,class K>
struct AVLTreeNode
{
//使用键值对_val来存储节点内的数据值
pair<T, K> _val;
//left表示指向该节点左孩子节点的指针
AVLTreeNode<T, K>* _left;
//right表示指向该节点右孩子节点的指针
AVLTreeNode<T, K>* _right;
//parent表示指向该节点父节点的指针
AVLTreeNode<T, K>* _parent;
//_bf内存储节点的平衡因子
int _bf;


AVLTreeNode(const pair<T, K>& x)
:_val(x)
,_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_bf(0)
{

}

};

以上结构体AVLTreeNode就用于表示AVL树的节点，在此实现为类模板可以使得节点内存储任意类型的数据。并且在类当中显示实现构造函数，这样就可以在我们之后创建出节点之后自动的进行初始化的工作

2.2 AVL树的结构

在此AVL树的结构使用类AVLTree来封装实现，实现的代码如下所示：

template<class T,class K>
class AVLTree
{
//将表示节点的变量重命名，简化书写
typedef AVLTreeNode<T, K> Node;
public:


//……

private:
//root表示AVL树内的根结点指针
Node* root = nullptr;


};

2.2 AVL树插入功能实现

在AVL树当中节点插入的步骤其实在前半部分和二叉搜索树节点的插入是完全一样的，只不过是在完成插入之后进行平衡因子的更新；如果当前树的平衡因子绝对值已经超出要求还需要进行旋转的操作。

1.插入步骤

因此要实现插入的步骤如下：
1. 插入一个值按二叉搜索树规则进行插入。

2. 新增结点以后，只会影响祖先结点的高度，也就是可能会影响部分祖先结点的平衡因子，所以更新从新增结点->根结点路径上的平衡因子，实际中最坏情况下要更新到根，有些情况更新到中间就可以停止了，具体情况我们下面再详细分析。

注：在此节点的祖先就指该节点到根结点路径上的所有节点
例如以下示例：

在以上AVL树当中插入节点之后在如图所示的路径上的节点都是节点13的祖先

3. 更新平衡因子过程中没有出现问题，则插入结束

4. 更新平衡因子过程中出现不平衡，对不平衡子树旋转，旋转后本质调平衡的同时，本质降低了子树的高度，不会再影响上一层，所以插入结束。

那么在以上了解了插入的具体步骤之后，接下来我们就先将更新平衡因子之前的代码实现

bool Insert(const pair<T, K>& x)
{
//当更节点为空时就直接将root指向新创建的节点
if (root == nullptr)
{
root = new Node(x);
return true;
}
//创建变量cur从根节点进行查找值为x的节点
Node* cur = root;
//parent用于表示cur节点的父节点指针
Node* parent = nullptr;
//一直查找到cur指向空
while (cur)
{
//当前节点内地数据值小于x，就说明新节点应该在该节点的右边
if (cur->_val.first < x.first)
{
parent = cur;
cur = cur->_right;

}
//当前节点内地数据值大于x，就说明新节点应该在该节点的左边
else if (cur->_val.first > x.first)
{
parent = cur;
cur = cur->_left;
}
//查找到值相同的节点就直接返回false
else
{
return false;
}
}
//创建值为x的节点
cur = new Node(x);

//判断新创建的节点是parent节点左孩子还是右孩子
//若节点内的数据值比parent指向的节点内的数据小就为左孩子
if (parent->_val.first > x.first)
{
parent->_left = cur;
}
//若节点内的数据值比parent指向的节点内的数据大就为右孩子
else
{
parent->_right = cur;

}
//将新创建的节点内的_parent指向其父节点
cur->_parent = parent;




//更新平衡因子操作
    //……


}

注：在此我们实现的AVL树是不支持冗余的，也就是树当中是不能出现重复元素的，因此在以上查找中如果出现相同值得节点就直接返回false；表示插入失败

2.平衡因子更新

在以上我们已经将更新平衡因子之前的代码实现，那么接下来我们就来了解该如何进行平衡因子的更新

更新原则：

在此确定节点的平衡因子 = 右子树高度-左子树高度，只有子树高度变化才会影响当前结点平衡因子。当插入结点时，会增加高度，所以新增结点在parent的右子树，parent的平衡因子++，新增结点在parent的左子树，parent平衡因子--，parent所在子树的高度是否变化决定了是否会继续往上更新

以上原则总结如下所示：
• 只有子树高度变化才会影响当前结点平衡因⼦。
• 插入结点，会增加高度，所以新增结点在parent的右子树，parent的平衡因子++，新增结点在parent的左子树，parent平衡因子--
• parent所在子树的高度是否变化决定了是否会继续往上更新

在了解了平衡因子的更新原则之后在AVL树从下往上的更新过程中需要知道什么时候应该停止更新，接下来就来分析看看

1.如果一个节点更新之后的平衡因子变为0就说明以该节点为根的子树在之前是一边高一边底的，在插入节点之后就使得这个子树左右完全平衡，这时到该节点之后就不需要再向上进行平衡因子的更新了

例如以下示例：

更新到中间结点，3为根的子树高度不变，不会影响上⼀层，更新结束

2.当更新到的节点平衡因子为-1或者1时就说明以该节点为根节点的子树从一开始平衡的状态到现在两边一边高一边底的状态，这时可能就会使得该节点祖先的平衡因子受到，因此要继续向上更新。这时最坏的情况就是更新到整课树的根结点才结束。

例如以下示例：

最坏更新到根停止

3.如果更新到一个节点的平衡因子变为了2或者-2，这时就说明已经超出满足AVL树最大限度；这时就需要进行旋转来使得此时的树变为AVL树，在此进行旋转之后就不需要再向上进行平衡因子的更新。

例如以下示例：
更新到10结点，平衡因子为2，10所在的子树已经不平衡，需要旋转处理

因此更新停止条件总结如下：
• 更新后parent的平衡因子等于0，更新中parent的平衡因子变化为-1->0 或者 1->0，说明更新前
parent子树一边高一边低，新增的结点插入在低的那边，插入后parent所在的子树高度不变，不会
影响parent的父亲结点的平衡因子，更新结束。
• 更新后parent的平衡因子等于1 或 -1，更新前更新中parent的平衡因子变化为0->1 或者 0->-1，说明更新前parent子树两边⼀样高，新增的插入结点后，parent所在的子树一边高一边低，parent所在的子树符合平衡要求，但是高度增加了1，会影响parent的父亲结点的平衡因子，所以要继续向上更新。
• 更新后parent的平衡因子等于2 或 -2，更新前更新中parent的平衡因子变化为1->2 或者 -1->-2，说明更新前parent子树一边高一边低，新增的插入结点在高的那边，parent所在的子树高的那边更高了，破坏了平衡，parent所在的子树不符合平衡要求，需要旋转处理，旋转的目标有两个：1、把parent子树旋转平衡。2、降低parent子树的高度，恢复到插入结点以前的高度。所以旋转后也不需要继续往上更新，插入结束。
• 不断更新，更新到根，跟的平衡因子是1或-1也停止了。

3.旋转

在以上我们了解了平衡因子的更新原则和结束条件之后，来了解旋转有哪些的分类，不同的旋转适用于什么样的场景

旋转的原则

1. 保持搜索树的规则
2. 让旋转的树从不满足变平衡，其次降低旋转树的高度
旋转总共分为四种，左单旋/右单旋/左右双旋/右左双旋。

注：下面的图中，有些结点我们给的是具体值，如10和5等结点，这里是为了方便讲解，实际中是什么值都可以，只要大小关系符合搜索树的性质即可。

1.右单旋

在旋转当中我们先来了解右单旋，当AVL树出现以下情况的结构时就需要使用右单旋

在以上图示当中a、b、c抽象的表示高度为为h的子树，并且这些子树都满足AVL树的要求，那么这时如果在子树a当中插入新的节点就会导致根节点的平衡因子变为-2，这时就需要进行右旋

本图展示的是10为根的树，有a/b/c抽象为三棵高度为h的子树(h>=0)，a/b/c均符合AVL树的要
求。10可能是整棵树的根，也可能是⼀个整棵树中局部的子树的根。这里a/b/c是高度为h的子树，
是⼀种概括抽象表示，他代表了所有右单旋的场景，实际右单旋形态有很多种。

• 在a子树中插入一个新结点，导致a子树的高度从h变成h+1，不断向上更新平衡因子，导致10的平
衡因子从-1变成-2，10为根的树左右高度差超过1，违反平衡规则。10为根的树左边太高了，需要
往右边旋转，控制两棵树的平衡。
• 旋转核心步骤，因为5 < b子树的值 < 10，将b变成10的左子树，10变成5的右子树，5变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的高度恢复到了插⼊之前的h+2，符合旋转原
则。如果插入之前10整棵树的⼀个局部⼦树，旋转后不会再影响上⼀层，插心结束了。

以下就将h等于0、1、2的情况具体描述看看

h等于0时

h等于1时

h等于2时

h等于3时

右单旋代码实现

//右单旋
void RotateR(Node* Parent)
{
//保存要进行右单旋的左孩子节点指针到SubL
Node* SubL = Parent->_left;
//保存SubL的右孩子节点指针到SubLR
Node* SubLR = SubL->_right;

//当h高度不为0时才将SubL的父指针指向Parent
if (SubLR != nullptr)
{
SubLR->_parent = Parent;
}
//保存Parent的父节点指针到ppNode
Node* ppNode = Parent->_parent;
//将Parent的左孩子指针指向SubLR，父节点指针指向SubL
Parent->_left = SubLR;
Parent->_parent = SubL;
//将SubL的右孩子节点指针指向Parent
SubL->_right = Parent;

//判断ppNode是否是根节点以下判断也可以写作Parent!=root

if (ppNode != nullptr)
{
if (ppNode->_left == Parent)
{
ppNode->_left = SubL;
}
else
{
ppNode->_right = SubL;
}
SubL->_parent = ppNode;

}
else
{
root = SubL;
SubL->_parent = nullptr;
}

//更新Parent和SubL的平衡因子
Parent->_bf = 0;
SubL->_bf = 0;


}

注：在以上代码当中要对h的高度为0和Parent为根节点的情况进行单独判断

2.左单旋

当AVL树出现以下情况的结构时就需要使用左单旋

在以上图示当中a、b、c抽象的表示高度为为h的子树，并且这些子树都满足AVL树的要求，那么这时如果在子树当中插入新的节点就会导致根节点的平衡因子变为2，这时就需要进行左旋

本下图展示的是10为根的树，有a/b/c抽象为三棵高度为h的子树(h>=0)，a/b/c均符合AVL树的要
求。10可能是整棵树的根，也可能是⼀个整棵树中局部的子树的根。这里a/b/c是高度为h的子树，
是⼀种概括抽象表示，他代表了所有右单旋的场景，实际右单旋形态有很多种，具体跟上面左旋类
似。

• 在a子树中插入⼀个新结点，导致a子树的高度从h变成h+1，不断向上更新平衡因子，导致10的平
衡因子从1变成2，10为根的树左右高度差超过1，违反平衡规则。10为根的树右边太高了，需要往
左边旋转，控制两棵树的平衡。
• 旋转核心步骤，因为10 < b子树的值 < 15，将b变成10的右子树，10变成15的左子树，15变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的高度恢复到了插入之前的h+2，符合旋转原则。如果插入之前10整棵树的⼀个局部子树，旋转后不会再影响上⼀层，插入结束了。

左单旋代码实现

//左单旋
void RotateL(Node* Parent)
{
//保存要进行左单旋的右孩子节点指针到SubR
Node* SubR = Parent->_right;
//保存SubR的左孩子节点指针到SubRL
Node* SubRL = SubR->_left;

//当h高度不为0时才将SubR的父指针指向Parent
if (SubRL != nullptr)
{
SubRL->_parent = Parent;
}
//保存Parent的父节点指针到ppNode
Node* ppNode = Parent->_parent;
//将Parent的右孩子指针指向SubRL，父节点指针指向SubR
Parent->_right = SubRL;
Parent->_parent = SubR;
//将SubR的右孩子节点指针指向Parent
SubR->_left = Parent;

//判断ppNode是否是根节点以下判断也可以写作Parent!=root
if (ppNode != nullptr)
{
if (ppNode->_left == Parent)
{
ppNode->_left = SubR;
}
else
{
ppNode->_right = SubR;
}
SubR->_parent = ppNode;
}
else
{
root = SubR;
SubR->_parent = nullptr;
}
//更新平衡因子
SubR->_bf = 0;
Parent->_bf = 0;
}

3.左右双旋

通过下图所示可以看到，左边高时，如果插入位置不是在a子树，而是插入在b子树，b子树高度从h变成h+1，引发旋转，右单旋无法解决问题，右单旋后，我们的树依旧不平衡。右单旋解决的纯粹的左边高，但是插入在b子树中，10为跟的子树不再是单纯的左边高，对于10是左边高，但是对于5是右边高，需要用两次旋转才能解决，以5为旋转点进行⼀个左单旋，以10为旋转点进行⼀个右单旋，这棵树这棵树就平衡了。

以上分别为左右双旋中h==0和h==1具体场景分析，下面我们将a/b/c子树抽象为高度h的AVL
子树进行分析，另外我们需要把b子树的细节进⼀步展开为8和左子树高度为h-1的e和f子树，因为
我们要对b的父亲5为旋转点进行左单旋，左单旋需要动b树中的左子树。b子树中新增结点的位置
不同，平衡因子更新的细节也不同，通过观察8的平衡因子不同，这里我们要分三个场景讨论。

• 场景1：h >= 1时，新增结点插入在e子树，e子树高度从h-1并为h并不断更新8->5->10平衡因子，引发旋转，其中8的平衡因子为-1，旋转后8和5平衡因⼦为0，10平衡因子为1。
• 场景2：h >= 1时，新增结点插入在f子树，f子树高度从h-1变为h并不断更新8->5->10平衡因子，引发旋转，其中8的平衡因子为1，旋转后8和10平衡因子为0，5平衡因子为-1。
• 场景3：h == 0时，a/b/c都是空树，b自己就是一个新增结点，不断更新5->10平衡因子，引发旋
转，其中8的平衡因子为0，旋转后8和10和5平衡因子均为0。

接下来再将场景1和场景2的左右双转过程图显示出：

场景一：

场景二：

左右双旋代码实现

完成了左右双旋的分析，接下来就试着来实现代码

在此在左右双旋过程中实际上就是分别进行左单旋和右单旋，所以在左右双旋中的旋转就不再需要我们自己再实现，直接通过调用之前实现的左旋和右旋即可。只不过接下来平衡因子的修改就需要我们自己来实现，在此要按照以上的三种场景进行平衡因子的修改。

代码实现如下所示：

//左右双旋
void RotateLR(Node* Parent)
{
//保存要进行左右单旋的左孩子节点指针SubL
Node* SubL = Parent->_left;
//保存SubL的右孩子节点指针SubLR
Node* SubLR = SubL->_right;
//使用bf保存SubLR的平衡因子
int bf = SubLR->_bf;
//以节点SubL节点进行左旋
RotateL(SubL);
//以节点Parent节点进行右旋
RotateR(Parent);
//更新平衡因子
//当h等于0时
if (bf == 0) 
{
SubL->_bf = 0;
SubLR->_bf = 0;
Parent->_bf = 0;
}
//当新插入的节点为SubLR的右孩子节点时
else if(bf==1)
{
SubL->_bf = -1;
Parent->_bf = 0;
SubLR->_bf = 0;
}
//当新插入的节点为SubLR的左孩子节点时
else if (bf == -1)
{
SubL->_bf = 0;
SubLR->_bf = 0;
Parent->_bf = 1;
}
//当出现其他的情况时就说明出现了错误，直接断言错误
else
{
assert(false);
}

}

4.右左双旋

跟左右双旋类似，下面我们将a/b/c子树抽象为高度h的AVL子树进行分析，另外我们需要把b子树的
细节进⼀步展开为12和左子树高度为h-1的e和f子树，因为我们要对b的父亲15为旋转点进行右单
旋，右单旋需要动b树中的右子树。b子树中新增结点的位置不同，平衡因子更新的细节也不同，通
过观察12的平衡因子不同，这里我们要分三个场景讨论。

• 场景1：h >= 1时，新增结点插入在e子树，e子树高度从h-1变为h并不断更新12->15->10平衡因
子，引发旋转，其中12的平衡因子为-1，旋转后10和12平衡因⼦为0，15平衡因子为1。
• 场景2：h >= 1时，新增结点插⼊在f子树，f子树高度从h-1变为h并不断更新12->15->10平衡因子，引发旋转，其中12的平衡因子为1，旋转后15和12平衡因子为0，10平衡因子为-1。
• 场景3：h == 0时，a/b/c都是空树，b自己就是⼀个新增结点，不断更新15->10平衡因子，引发旋
转，其中12的平衡因子为0，旋转后10和12和15平衡因子均为0。

接下来再将场景1和场景2的左右双转过程图显示出：

场景一：

场景2：

右左双旋代码实现

完成了右左双旋的分析，接下来就试着来实现代码

在此在右左双旋过程中实际上就是分别进行右单旋和左单旋，所以在右左双旋中的旋转就不再需要我们自己再实现，直接通过调用之前实现的右旋和左旋即可。只不过接下来平衡因子的修改就需要我们自己来实现，在此要按照以上的三种场景进行平衡因子的修改。

代码实现如下所示：

//右左单旋
void RotateRL(Node* Parent)
{
//保存要进行右左单旋的右孩子节点指针SubR
Node* SubR = Parent->_right;
//保存SubR的左孩子节点指针SubRL
Node* SubRL = SubR->_left;
//使用bf保存SubRL的平衡因子
int bf = SubRL->_bf;

//以节点SubR节点进行右旋
RotateR(SubR);
//以节点Parent节点进行左旋
RotateL(Parent);

//更新平衡因子
if (bf == 0)
{
SubR->_bf = 0;
SubRL->_bf = 0;
Parent->_bf = 0;
}
//当新插入的节点为SubRL的右孩子节点时
else if (bf == 1)
{
SubR->_bf = 0;
SubRL->_bf = 0;
Parent->_bf = -1;

}
//当新插入的节点为SubRL的左孩子节点时
else if (bf == -1)
{
SubRL->_bf = 0;
Parent->_bf = 0;
SubR->_bf = 1;
}
//当出现其他的情况时就说明出现了错误，直接断言错误
else
{
assert(false);
}

}

完整插入代码

bool Insert(const pair<T, K>& x)
{
//当更节点为空时就直接将root指向新创建的节点
if (root == nullptr)
{
root = new Node(x);
return true;
}
//创建变量cur从根节点进行查找值为x的节点
Node* cur = root;
//parent用于表示cur节点的父节点指针
Node* parent = nullptr;
//一直查找到cur指向空
while (cur)
{
//当前节点内地数据值小于x，就说明新节点应该在该节点的右边
if (cur->_val.first < x.first)
{
parent = cur;
cur = cur->_right;

}
//当前节点内地数据值大于x，就说明新节点应该在该节点的左边
else if (cur->_val.first > x.first)
{
parent = cur;
cur = cur->_left;
}
//查找到值相同的节点就直接返回false
else
{
return false;
}
}
//创建值为x的节点
cur = new Node(x);

//判断新创建的节点是parent节点左孩子还是右孩子
//若节点内的数据值比parent指向的节点内的数据小就为左孩子
if (parent->_val.first > x.first)
{
parent->_left = cur;
}
//若节点内的数据值比parent指向的节点内的数据大就为右孩子
else
{
parent->_right = cur;

}
//将新创建的节点内的_parent指向其父节点
cur->_parent = parent;
//更新平衡因子
while (parent)
{
if (parent->_left == cur)
{
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)
{
//右单旋
RotateR(parent);

}
else if (parent->_bf == 2 && cur->_bf == 1)
{
//左单旋
RotateL(parent);
}
else if (parent->_bf == -2 && cur->_bf == 1)
{
//左右双旋
RotateLR(parent);
}
else if (parent->_bf == 2 && cur->_bf == -1)
{
//右左双旋
RotateRL(parent);
}
break;
 
}
else
{
assert(false);
}

}
return true;

}

2.3 AVL树查找功能实现

在此AVL树当中的查找和二叉搜索树当中完全一致，在此就不再进行讲解，搜索效率为 O(logN)

实现代码如下所示：

Node* Find(const T&x)
{
if (root == nullptr)
{
return nullptr;
}
Node* cur=root;
while (cur)
{
if (cur->_val.first < x)
{
cur = cur->_right;
}
else if (cur->_val.first > x)
{
cur = cur->_left;
}
else
{
return cur;
}
}
return nullptr;

}

2.4 AVL树平衡检测

我们实现的AVL树是否合格，我们通过检查左右子树高度差的的程序进行反向验证，同时检查⼀下结点的平衡因子更新是否出现了问题。


void InOrder()
{
_InOrder(root);
cout << endl;
}



bool IsBalanceTree()
{
return _IsBalanceTree(root);
}


int  Height()
{
return _Height(root);
}


int Size()
{
return _Size(root);
}


private:
    void _InOrder(Node* cur)
    {
    if (cur == nullptr)
    {
    return;
    }
    _InOrder(cur->_left);
    cout << cur->_val.first <<":" << cur->_val.second << endl;
    _InOrder(cur->_right);

    }

    int _Height(Node* cur)
    {
    if (cur == nullptr)
    {
    return 0;
    }
    int Left = _Height(cur->_left);
    int Right = _Height(cur->_right);
    return Left > Right ? Left + 1 : Right + 1;
    }


    bool _IsBalanceTree(Node* root)
    {
    if (root == nullptr)
    {
    return true;
    }

    int HLeft = _Height(root->_left);
    int HRight = _Height(root->_right);
    int diff = HRight-HLeft;

    if (abs(diff) >= 2)
    {
    cout << root->_val.first << "⾼度差异常" << endl;
    return false;
    }
    if (root->_bf != diff)
    {
    cout << root->_val.first << "平衡因子异常" << endl;
    return false;
    }
    // pRoot的左和右如果都是AVL树，则该树⼀定是AVL树
    return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);


    }


    int _Size(Node* cur)
    {
    if (cur == nullptr)
    {
    return 0;
    }

    return 1 + _Size(cur->_left) + _Size(cur->_right);

    }

测试代码1：

void TestAVLTree1()
{
AVLTree<int, int> t;
// 常规的测试⽤例
//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
// 特殊的带有双旋场景的测试⽤例
int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
for (auto e : a)
{
t.Insert({ e, e });
}
t.InOrder();
cout << t.IsBalanceTree() << endl;
}

程序输出结果如下所示：

测试代码2：
在以上的测试1当中我们只是使用两个用例来测试，这不能说明代码是完全没有问题的，那么接下来我们就来使用更加严谨的方式来验证

void TestAVLTree2()
{
const int N = 100000;
vector<int> v;
v.reserve(N);
srand(time(0));
for (size_t i = 0; i < N; i++)
{
v.push_back(rand() + i);
}
size_t begin2 = clock();
AVLTree<int, int> t;
for (auto e : v)
{
t.Insert(make_pair(e, e));
}
size_t end2 = clock();
cout << t.IsBalanceTree() << endl;
cout << "Insert:" << end2 - begin2 << endl;

cout << "Height:" << t.Height() << endl;
cout << "Size:" << t.Size() << endl;
size_t begin1 = clock();
// 确定在的值
/*for (auto e : v)
{
t.Find(e);
}*/
// 随机值
for (size_t i = 0; i < N; i++)
{
t.Find((rand() + i));
}
size_t end1 = clock();
cout << "Find:" << end1 - begin1 << endl;
}