hello，各位小伙伴，本篇文章跟大家一起学习《C++：平衡搜索二叉树（AVL）》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！
文章目录
🍁AVL树
上篇我们讲到了二叉搜索树，二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
AVL树是具有以下性质的搜索二叉树：
- 它的左右子树都是AVL树
- 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
那么可以得出：假设一颗AVL树有n个节点，那么其高度可保持在 O ( l o g 2 n ) O(log_2 n) O(log2n)，搜索时间复杂度O( l o g 2 n log_2 n log2n)。
🍁AVL树节点的定义
先看代码：
template<class K,class V>
struct AVLTreeNode
{
pair<K, V> _kv;
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)
{}
};
- 由于要保证左右子树高度之差的绝对值不超过1(-1/0/1)，所以引用了平衡因子
_bf来维护，平衡因子的计算为右子树高度减去左子树高度 - 因为AVL树会对节点进行旋转，所以引入了父节点指针
_parent来维护
🍃关于pair
在C++中，pair是一个模板类，用于将两个值（通常是不同类型的值）组合成一个单元，称为键-值对。pair允许我们将两个值一起存储、传递和操作，非常适合需要成对操作的场景。
基本用法：
要使用pair，首先需要包含 <utility> 头文件，因为pair定义在这个头文件中。
但是在某些编译环境中，尤其是较新版本的C++标准中，pair可能会隐式地包含在一些其他标准头文件中，例如 <iostream>或 <map>。这种情况下，您可能会发现在不包含 <utility> 头文件的情况下也能使用pair。
#include <utility>
#include <iostream>
int main() {
// 创建一个键-值对
std::pair<int, std::string> student(1, "Alice");
// 访问键和值
std::cout << "ID: " << student.first << ", Name: " << student.second << std::endl;
// 修改键和值
student.first = 2;
student.second = "Bob";
std::cout << "ID: " << student.first << ", Name: " << student.second << std::endl;
return 0;
}
pair还提供了成员函数用于访问其成员：
- first：访问第一个元素（键）
- second：访问第二个元素（值）
使用示例：
pair在STL中广泛使用，特别是在关联容器中（如map和multimap）存储键值对。例如，使用pair可以方便地在map中插入元素：
#include <iostream>
#include <map>
int main() {
std::map<int, std::string> studentMap;
// 插入键-值对
studentMap.insert(std::make_pair(1, "Alice"));
studentMap.insert(std::make_pair(2, "Bob"));
studentMap.insert(std::make_pair(3, "Charlie"));
// 遍历并打印所有键-值对
for (const auto& pair : studentMap) {
std::cout << "ID: " << pair.first << ", Name: " << pair.second << std::endl;
}
return 0;
}
🍁AVL树的插入
AVL树本质上就是搜索二叉树，所以插入的规则和搜索二叉树是一样的，只不过多了一个步骤：调整平衡因子
先看代码：
bool Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
parent = cur;
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--
parent->_bf--;
}
else
{
// 如果插入的位置为父节点的右边，则parent->_bf++
parent->_bf++;
}
if (parent->_bf == 0)
{
// 如果该结点_bf的值为0，则无需继续向上调整，直接break
break;
}
else if (parent->_bf == 1 || parent->_bf == -1)
{
// 如果该结点_bf的值为1或者-1，则继续向上调整
cur = parent;
parent = parent->_parent;
}
else if (parent->_bf == 2 || parent->_bf == -2)
{
// 如果该结点_bf的值为2或者-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
{
// 双旋操作
RotateLR(parent);
}
break;
}
else
{
assert(0);
}
}
return true;
}
🍁AVL树的旋转
当插入新节点后，AVL树不再平衡，就要进行旋转操作，AVL树的旋转分四种情况：
- 新节点插入较高左子树的左侧：右单旋
右旋实现代码：
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
Node* parentParent = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
// 关键点：当parentParent == nullptr，就要注意根节点的改变
if (parentParent == nullptr)// 更改根节点
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (parent == parentParent->_left)
{
parentParent->_left = subL;
}
else
{
parentParent->_right = subL;
}
subL->_parent = parentParent;
}
parent->_bf = subL->_bf = 0;// 调整平衡因子
}
- 新节点插入较高右子树的右侧：左单旋
那么左旋道理也是一样，直接看代码：
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
Node* parentParent = parent->_parent;
subR->_left = parent;
parent->_parent = subR;
if (parentParent == nullptr)// 更改根节点
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parent == parentParent->_left)
{
parentParent->_left = subR;
}
else
{
parentParent->_right = subR;
}
subR->_parent = parentParent;
}
parent->_bf = subR->_bf = 0;// 调整平衡因子
}
- 新节点插入较高左子树的右侧—左右：先左单旋再右单旋
实现代码：
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;// 记录旋转前的平衡因子
RotateL(parent->_left);
RotateR(parent);
// 但是调整平衡因子就有点麻烦了
// 3种情况
if (bf == 0)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 1;
}
else if (bf == -1)
{
subL->_bf = -1;
subLR->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
- 新节点插入较高右子树的左侧—右左：先右单旋再左单旋
实现代码：
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == 0)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = -1;
}
else if (bf == -1)
{
subR->_bf = 1;
subRL->_bf = 0;
parent->_bf = 0;
}
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是否平衡
int _Height(Node* pRoot)
{
if (pRoot == nullptr)
{
return 0;
}
return _Height(pRoot->_left) > _Height(pRoot->_right) ? _Height(pRoot->_left) + 1 : _Height(pRoot->_right) + 1;
}
bool _IsBalanceTree(Node* pRoot)
{
// 空树也是AVL树
if (nullptr == pRoot) return true;
// 计算pRoot节点的平衡因子：即pRoot左右子树的高度差
int leftHeight = _Height(pRoot->_left);
int rightHeight = _Height(pRoot->_right);
int diff = rightHeight - leftHeight;
// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
// pRoot平衡因子的绝对值超过1，则一定不是AVL树
if (diff != pRoot->_bf || (diff > 1 || diff < -1))
return false;
// pRoot的左和右如果都是AVL树，则该树一定是AVL树
return _IsBalanceTree(pRoot->_left) && _IsBalanceTree(pRoot ->_right);
void test()
{
cout<< _IsBalanceTree(_root) << endl;
}
}
创建好AVL树后，直接在主函数调用test()就可以了
🍁AVL树的Find和Erase
Find和搜索二叉树没什么区别：
Node* Find(const pair<K,V> kv)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < kv.first)
{
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
cur = cur->_left;
}
else
return cur;
}
return nullptr;
}
Erase就有点麻烦了，删除后要保证平衡
举个例子：
要比25小，而且要比10大，很显然只需要寻找?节点左子树最大节点和右子树最小节点即可，那么我们选择左子树最大节点15
实现代码：
注意：下列代码并没有实现删除后平衡因子的调整！！！
bool Erase(const pair<K, V>kv)
{
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
// 寻找节点
if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
else// 找到后进行删除操作
{ // 1、0个孩子
if (cur->_left == nullptr)
{
if (parent == nullptr)
{
_root = cur->_right;
return true;
}
if (parent->_left == cur)
parent->_left = cur->_right;
else
parent->_right = cur->_right;
delete cur;
return true;
}
else if (cur->_right == nullptr)
{
if (parent == nullptr)
{
_root = cur->_left;
return true;
}
if (parent->_left == cur)
parent->_left = cur->_left;
else
parent->_right = cur->_left;
delete cur;
return true;
}
// 2个孩子
else
{ // 找右边最小的rightmin
Node* rightminP = cur;
Node* rightmin = cur->_right;
while (rightmin->_left)
{
rightminP = rightmin;
rightmin = rightmin->_left;
}
cur->_kv.first = rightmin->_kv.first;
if (rightminP->_left == rightmin)
{
rightminP->_left = rightmin->_right;
}
else
{
rightminP->_right = rightmin->_right;
}
delete rightmin;
return true;
}
}
}
return false;
}
对于删除具体实现可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。
🍁AVL树的性能
AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即 l o g 2 ( N ) log_2 (N) log2(N)。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。
🍁AVL树实现的总代码
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
template<class K,class V>
struct AVLTreeNode
{
pair<K, V> _kv;
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)
{}
};
template<class K, class V>
class AVLT
{
typedef AVLTreeNode<K, V> Node;
public:
AVLT() = default;
/*AVLT(const AVLT<K, V> t)
{
_root = Copy(t._root);
}*/
AVLT& operator=(AVLT<K, V> t)
{
swap(_root, t._root);
return *this;
}
~AVLT()
{
Destroy(_root);
_root = nullptr;
}
void RotateL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL)
subRL->_parent = parent;
Node* parentParent = parent->_parent;
subR->_left = parent;
parent->_parent = subR;
if (parentParent == nullptr)// 更改根节点
{
_root = subR;
subR->_parent = nullptr;
}
else
{
if (parent == parentParent->_left)
{
parentParent->_left = subR;
}
else
{
parentParent->_right = subR;
}
subR->_parent = parentParent;
}
parent->_bf = subR->_bf = 0;
}
void RotateR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
subLR->_parent = parent;
Node* parentParent = parent->_parent;
subL->_right = parent;
parent->_parent = subL;
if (parentParent == nullptr)// 更改根节点
{
_root = subL;
subL->_parent = nullptr;
}
else
{
if (parent == parentParent->_left)
{
parentParent->_left = subL;
}
else
{
parentParent->_right = subL;
}
subL->_parent = parentParent;
}
parent->_bf = subL->_bf = 0;
}
void RotateRL(Node* parent)
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
int bf = subRL->_bf;
RotateR(parent->_right);
RotateL(parent);
if (bf == 0)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subR->_bf = 0;
subRL->_bf = 0;
parent->_bf = -1;
}
else if (bf == -1)
{
subR->_bf = 1;
subRL->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
void RotateLR(Node* parent)
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
int bf = subLR->_bf;
RotateL(parent->_left);
RotateR(parent);
if (bf == 0)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 0;
}
else if (bf == 1)
{
subL->_bf = 0;
subLR->_bf = 0;
parent->_bf = 1;
}
else if (bf == -1)
{
subL->_bf = -1;
subLR->_bf = 0;
parent->_bf = 0;
}
else
{
assert(false);
}
}
bool Insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
return true;
}
Node* parent = nullptr;
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
parent = cur;
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)
{
// 不平衡了，旋转处理
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
{
RotateLR(parent);
}
break;
}
else
{
assert(0);
}
}
return true;
}
Node* Find(const pair<K,V> kv)
{
Node* cur = _root;
while (cur)
{
if (cur->_kv.first < kv.first)
{
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
cur = cur->_left;
}
else
return cur;
}
return nullptr;
}
bool Erase(const pair<K, V>kv)
{
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
else
{ // 1、0个孩子
if (cur->_left == nullptr)
{
if (parent == nullptr)
{
_root = cur->_right;
return true;
}
if (parent->_left == cur)
parent->_left = cur->_right;
else
parent->_right = cur->_right;
delete cur;
return true;
}
else if (cur->_right == nullptr)
{
if (parent == nullptr)
{
_root = cur->_left;
return true;
}
if (parent->_left == cur)
parent->_left = cur->_left;
else
parent->_right = cur->_left;
delete cur;
return true;
}
// 2个孩子
else
{ // 找右边最小的rightmin
Node* rightminP = cur;
Node* rightmin = cur->_right;
while (rightmin->_left)
{
rightminP = rightmin;
rightmin = rightmin->_left;
}
cur->_kv.first = rightmin->_kv.first;
if (rightminP->_left == rightmin)
rightminP->_left = rightmin->_right;
else
rightminP->_right = rightmin->_right;
delete rightmin;
return true;
}
}
}
return false;
}
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;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
int _Height(Node* pRoot)
{
if (pRoot == nullptr)
{
return 0;
}
return _Height(pRoot->_left) > _Height(pRoot->_right) ? _Height(pRoot->_left) + 1 : _Height(pRoot->_right) + 1;
}
bool _IsBalanceTree(Node* pRoot)
{
// 空树也是AVL树
if (nullptr == pRoot) return true;
// 计算pRoot节点的平衡因子：即pRoot左右子树的高度差
int leftHeight = _Height(pRoot->_left);
int rightHeight = _Height(pRoot->_right);
int diff = rightHeight - leftHeight;
// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
// pRoot平衡因子的绝对值超过1，则一定不是AVL树
if (diff != pRoot->_bf || (diff > 1 || diff < -1))
return false;
// pRoot的左和右如果都是AVL树，则该树一定是AVL树
return _IsBalanceTree(pRoot->_left) && _IsBalanceTree(pRoot ->_right);
}
void test()
{
cout<< _IsBalanceTree(_root) << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << " ";
_InOrder(root->_right);
}
void Destroy(Node* root)
{
if (root == nullptr)
return;
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
Node* _root = nullptr;
};
你学会了吗？
好啦，本章对于《C++：平衡搜索二叉树（AVL）》的学习就先到这里，如果有什么问题，还请指教指教，希望本篇文章能够对你有所帮助，我们下一篇见！！！
如你喜欢，点点赞就是对我的支持，感谢感谢！！！
3579
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
