C++《AVL树》
在之前的学习当中我们已经相识了二叉搜索树，而且我们知道二叉搜索树的查找服从是无法满意我们的要求，当二叉树为左大概右斜树查找的服从就很低下了，那么这本篇当中我们就要来学习对二叉搜索树举行优化的二叉树——AVL树。在此会先来相识AVL树是什么，之后再学习AVL树的结构特点，末了会试着来实现AVL树的结构。在AVL树当中各种旋转是较难懂确的，须要我们静下心来明白，一起加油吧！！！https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvZGJkMGJhNDE1NTY3NDYzYzlmN2MzOTY4NjhhNWU1MjUuZ2lm
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
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvYjMwYjBjNTk0N2M0NDA2MjgzMDQ5Njk2MDEyOWZhZmEucG5n
固然AVL树无法做到包管全部子树没有高度差，但每个子树高度差最大就为2，这就使得AVL树团体结点数量和分布和完全二叉树类似，高度以控制在 logN ，那么增删查改的服从也可以控制在 O(logN) ，相比二叉搜索树有了本质的提升。
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMzhlZDIxNjk3ODI1NDAyMmIzYWI5ZDlhNTMwYzNkOTUucG5n
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMDNhYTdlNGZhZDRiNGM1OGIwMmI3MTFjZGY0OWMwNWIucG5n
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. 新增结点以后，只会影响先人结点的高度，也就是大概会影响部门先人结点的均衡因子，以是更新重新增结点->根结点路径上的均衡因子，现实中最坏环境下要更新到根，有些环境更新到中央就可以制止了，详细环境我们下面再详细分析。
注：在此节点的先人就指该节点到根结点路径上的全部节点
比方以下示例：
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvNGZjMmU2M2E5MjUwNDZkZjgzYjM5YzllZTI3YTM3NzcucG5n
在以上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为根的子树高度稳固，不会影响上⼀层，更新竣事
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMTMyYzUzYWU4OTZlNDdhYTgwMzM2Njc0ZWEzZTU3YWUucG5n
2.当更新到的节点均衡因子为-1大概1时就分析以该节点为根节点的子树从一开始均衡的状态到如今两边一边高一边底的状态，这时大概就会使得该节点先人的均衡因子受到，因此要继承向上更新。这时最坏的环境就是更新到整课树的根结点才竣事。
比方以下示例：
最坏更新到根制止
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvODBkM2RjMjg5OWI5NGNkYjkwNzlmMzNmMzY0ODgxZjEucG5n
3.假如更新到一个节点的均衡因子变为了2大概-2，这时就分析已经超出满意AVL树最大限度；这时就须要举行旋转来使得此时的树变为AVL树，在此举行旋转之后就不须要再向上举行均衡因子的更新。
比方以下示例：
更新到10结点，均衡因子为2，10所在的子树已经不均衡，须要旋转处理处罚
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvZjM4NWYxZmM5ZDc3NDRlNzhkZjM2ZTcxN2JmODBiNTkucG5n
因此更新制止条件总结如下：
• 更新后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树出现以下环境的结构时就须要利用右单旋
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvOWRjN2Q2ZTY5ODJmNDMxNGI1NzdiZWExZDYxMDM3ODQucG5n在以上图示当中a、b、c抽象的表现高度为为h的子树，而且这些子树都满意AVL树的要求，那么这时假如在子树a当中插入新的节点就会导致根节点的均衡因子变为-2，这时就须要举行右旋
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvOGU5Y2JiNWQzMzVlNDc2ZDkzYTFhNzY0MzhlNTYyMjYuZ2lm
本图展示的是10为根的树，有a/b/c抽象为三棵高度为h的子树(h>=0)，a/b/c均符合AVL树的要
求。10大概是整棵树的根，也大概是⼀个整棵树中局部的子树的根。这里a/b/c是高度为h的子树，
是⼀种概括抽象表现，他代表了全部右单旋的场景，现实右单旋形态有许多种。https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvYmFhYmI2ZTFmZTgxNGI1OTgzZGFhMmUzMmNiZWI5YjcucG5n
• 在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时
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvZTc2NDAyNzAzM2EwNDdmZDlkNzg3MjM1Yjk4ZDBiMjMucG5n
h便是1时
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvOWRjNDRhNWI4YWVhNDVjNDllMDAxODk1ZGVkOGVkOTgucG5n
h便是2时
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvNjAxYjcwODhiZjc0NDU0YTliN2JjZWE1MDAwZThiN2QucG5n
h便是3时
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMWY1MmUzYjUyNDliNDZlZjkyNjI2NjVhM2FkMDI1YzUucG5n
右单旋代码实现
//右单旋
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树出现以下环境的结构时就须要利用左单旋
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvODc2ZmEyZmFiMjVmNGI5Yzg4MDM0Yjg2ZDg0MDQxMTkucG5n
在以上图示当中a、b、c抽象的表现高度为为h的子树，而且这些子树都满意AVL树的要求，那么这时假如在子树当中插入新的节点就会导致根节点的均衡因子变为2，这时就须要举行左旋
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvNWEzZjBiNWFjOTlhNDY1ODgzOGQ2ODhhOGYwMTNmYzMuZ2lm
本下图展示的是10为根的树，有a/b/c抽象为三棵高度为h的子树(h>=0)，a/b/c均符合AVL树的要
求。10大概是整棵树的根，也大概是⼀个整棵树中局部的子树的根。这里a/b/c是高度为h的子树，
是⼀种概括抽象表现，他代表了全部右单旋的场景，现实右单旋形态有许多种，详细跟上面左旋类
似。
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMGZiMTdkYzgwNjI4NGQ4MjgzOWYyMmExMjljY2RiODgucG5n
• 在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为旋转点举行⼀个右单旋，这棵树这棵树就均衡了。
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvYmU0MDc4NzFmNmYxNDg3YzkxMGZiMmQ2MjAyMmY3MDUucG5n
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvOTY5MDZiNTk1ODZhNGJmZWJlMzhmY2RmMjNhY2I2MDkucG5n
以上分别为左右双旋中h==0和h==1详细场景分析，下面我们将a/b/c子树抽象为高度h的AVL
子树举行分析，别的我们须要把b子树的细节进⼀步睁开为8和左子树高度为h-1的e和f子树，由于
我们要对b的父亲5为旋转点举行左单旋，左单旋须要动b树中的左子树。b子树中新增结点的位置
差别，均衡因子更新的细节也差别，通过观察8的均衡因子差别，这里我们要分三个场景讨论。
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMTI3YmM4YTNmYjVkNDAzOWEyM2Y3MzI2YmIwMmI1MzIucG5n
• 场景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的左右双转过程图表现出：
场景一：
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvNDIxZWY1M2ZiYjljNDJiN2EyMzllZDk3MDQ1YmUyNWEuZ2lm
场景二：
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvNTU3M2RlNmYxMmVlNGVmZWI3MDViZWY0OWRmMTMxMmYuZ2lm
左右双旋代码实现
完成了左右双旋的分析，接下来就试着来实今世码
在此在左右双旋过程中现实上就是分别举行左单旋和右单旋，以是在左右双旋中的旋转就不再须要我们自己再实现，直接通过调用之前实现的左旋和右旋即可。只不外接下来均衡因子的修改就须要我们自己来实现，在此要按照以上的三种场景举行均衡因子的修改。
代码实现如下所示：
//左右双旋
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的均衡因子差别，这里我们要分三个场景讨论。
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMjliNjMxNWI3NDhlNDBmMGJjZjdiNWFkMjJjNDllNzgucG5n
• 场景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的左右双转过程图表现出：
场景一：
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvOWQ3MzZhMGQ4OWYwNDE0MmIxMGNhODU5MDc0ZDUzZDYuZ2lm
场景2：
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvYTcyODBkZTNmNTVmNGExZGI0MjNlYzNlODEyMWQ3MmEuZ2lm
右左双旋代码实现
完成了右左双旋的分析，接下来就试着来实今世码
在此在右左双旋过程中现实上就是分别举行右单旋和左单旋，以是在右左双旋中的旋转就不再须要我们自己再实现，直接通过调用之前实现的右旋和左旋即可。只不外接下来均衡因子的修改就须要我们自己来实现，在此要按照以上的三种场景举行均衡因子的修改。
代码实现如下所示：
//右左单旋
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);
}
intHeight()
{
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;
} 步伐输出结果如下所示：
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvOTc4NjQ2NDg3MmQ3NDU0YjljNDkzMDY5NWMxMTMyYmQucG5n https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvODE4ZDE3MzE4OTNkNGVlNjliNjUwNTM4ZDM2ODI5MzEucG5n
测试代码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;
}
步伐输出结果如下所示：
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMmQzNTAyNTc2ZDdkNGNlOGI2ZWM5OTA3YWNhNGYwOTUucG5nhttps://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvZDNiY2MxMzVkNzI5NGQ0ZGIyMDA2MWMwMzg4Y2FkMDYucG5n
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvYTc0ZmFlOGUxNzgxNGZkZTkzYzM0Mjc2NTA2YmUzMDMucG5nhttps://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvMzg5YzY2OWUzMjU0NDRjOWFmYTRjZWI2NjFmNzZkZTUucG5n
通过以上的输出结果就可以看出我们实现的AVL树各个功能都是没题目的，而且通过输出的结果还可以看出在AVL树当中的查找服从是很高的，查找6万的数据仅仅只须要20次左右
以上就是本篇的全部内容了，盼望通过本篇的解说你能明白AVL树的干系知识，接下来在其他章节还会带来其他数据结构的知识，未完待续……
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]