C/C++ 进阶（5）二叉平衡搜索树（AVL树）

已于 2024-07-24 00:28:55 修改
阅读量631 收藏 14
点赞数 25
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-06-04 22:08:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73435980/article/details/139420385
版权

个人主页：仍有未知等待探索-CSDN博客

专题分栏：C++

目录

一、概念

节点结构 

二、平衡因子

三、操作

插入

旋转

左单旋

右单旋

左右双旋

右左双旋

四、总代码

一、概念

二叉平衡搜索树又称AVL树，是一种特殊的二叉搜索树。一般的二叉搜索树在遇到数据有序时，查找的效率比较的低。

而二叉平衡搜索树，为了防止有这种极端的情况出现，其保证了任一节点的左右子树的高度差不超过1，通过控制高度，使查找的次数降低。 

节点结构 

左孩子，右孩子，双亲指针，值，平衡因子

template<class T, class V>
struct AVLN
{
	typedef pair<T, V> PTV;
	AVLN(const PTV& e)
		:parent(nullptr)
		,left(nullptr)
		,right(nullptr)
		,val(e)
		,bf(0)
	{}
	AVLN<T, V>* parent;
	AVLN<T, V>* left;
	AVLN<T, V>* right;
	PTV val;
	int bf;
};

二、平衡因子

二叉平衡搜索树，在对节点的结构进行定义的时候多添加了一个平衡因子的变量（bf），用来判断树是否是平衡的。

平衡因子 = 右子树的高度 - 左子树的高度

平衡因子的取值为 ：0、+1、-1、+2、-2

当平衡因子为+2、-2的时候，代表了这棵树需要进行调整。

三、操作

插入

插入的步骤就是这些。

为什么调节完，平衡因子为1、-1的时候要向上进行调整？ 

如果调节完，平衡因子为1、-1，则在没有调整的时候，平衡因子为0。新增了一个结点之后，高度发生了变化。以当前节点为根节点的子树的高度发生了变化，则以当前节点为其中的一个节点的子树的高度也同样发生了变化，所以需要进行调整。

旋转

对于要通过旋转进行调节平衡因子的情况不细分的话，有4种：左单旋、右单旋、左右双旋、右左双旋。

注意：在进行旋转的时候，对于每个节点的指针变化，要特别的细心。

节点中有三个指针，一个指向左孩子、一个指向右孩子、另外一个指向双亲。

旋转点：进行旋转的一个基准点。就比如左单旋的话，parent就是旋转点。

左单旋

左单旋变换：subrl 变成 parent 的右子树，parent 成为 subr 的左子树。

直接看图变换是不难，但是写代码就会有很多的坑（指针的变换）。

// 左单旋
// 参数是图中的parent，也称为旋转点
void RotateL(node* parent)
{
	node* subr = parent->right;
	node* subrl = subr->left;
    
    // subrl 成为 parent 的右子树 
	parent->right = subrl;
	if (subrl)
		subrl->parent = parent;

	subr->left = parent;
	node* pparent = parent->parent;

	parent->parent = subr;

	if (_root != parent)
	{

		if (pparent->left == parent)
		{
			pparent->left = subr;
		}
		else 
		{
			pparent->right = subr;
		}
		subr->parent = pparent;
	}
	else
	{
		_root = subr;
		subr->parent = nullptr;
	}

	parent->bf = subr->bf = 0;
}

右单旋

如图是右单旋的情况。

右单旋的变换：sublr 变成 parent 的左子树，将parent 变成 subl 的右子树。

直接看图变换是不难，但是写代码就会有很多的坑（指针的变换）。

// 右单旋
// parent 为旋转点
void RotateR(node* parent)
{
	node* subl = parent->left;
	node* sublr = subl->right;
    
    // sublr成为parent的左子树
	parent->left = sublr;
    // 如果sublr是空的话，不需要更新它的双亲结点，因为空指针不能进行解引用
	if (sublr)
		sublr->parent = parent;
    
    // parent成为subl的右子树
	subl->right = parent;
    // 记录一下这个子树的根节点的双亲结点
	node* pparent = parent->parent;
    
    // 更新parent的双亲节点
	parent->parent = subl;
    
    // 判断该子树的根节点是不是整个子树的根节点
    // 不是的话，也需要更新该子树的根节点的双亲结点
	if (_root != parent)
	{
		
		if (pparent->left == parent)
		{
			pparent->left = subl;
		}
		else 
		{
			pparent->right = subl;
		}
		subl->parent = pparent;
	}
	else
	{
		_root = subl;
		subl->parent = nullptr;
	}
    
    // 更新平衡因子
	parent->bf = subl->bf = 0;
}

左右双旋

左右双旋的变换：先以 subl 为旋转点进行左单旋，然后再以 parent 为旋转点进行右单旋。

注意：1、指针的变换 2、注意新的节点插入在 b 子树的左子树和右子树的时候，平衡因子的变化。

 

// 左右双旋
// 传参传的节点还是parent
void RotateLR(node* parent)
{
	node* psubl = parent->left;
	node* psublr = psubl->right;
    
    // 记录之前的 sublr 节点的平衡因子
	int bf = psublr->bf;
    
    // 先以 subl 为旋转点进行左单旋
	RotateL(parent->left);
    // 然后再以 parent 为旋转点进行右单旋
	RotateR(parent);
    
    // 在完成旋转调整平衡后，在对该子树的平衡因子进行变换
    // 至于为什么平衡因子等于这些值，可以去看看我画的图然后进行对比
    // 还是比较清楚的
	if (-1 == bf)
	{
		psubl->bf = psublr->bf = 0;
		parent->bf = 1;
	}
	else if (1 == bf)
	{
		parent->bf = psublr->bf = 0;
		psubl->bf = -1;	
	}
	else if (0 == bf) // 如果在旋转之前的平衡因子就是为0，则调整完之后的平衡因子都是0
	{
		parent->bf = psubl->bf = psublr->bf = 0;
	}
	else // 这种情况一般是没有的，如果有，则是你写的AVL树是有错误的
	{
		assert(false);
	}
}

右左双旋

右左双旋的变换：先以 subr 为旋转点进行右单旋，然后再以 parent 为旋转点进行左单旋。

注意：1、指针的变换 2、注意新的节点插入在 c 子树的左子树和右子树的时候，平衡因子的变化。

// 右左双旋
void RotateRL(node* parent)
{
	node* psubr = parent->right;
	node* psubrl = parent->left;
	int bf = psubrl->bf;
    
    // 先以subr为旋转点进行右单旋
	RotateR(parent->right);
    // 再以parent为旋转点进行左单旋
	RotateL(parent);
    
    // 更新平衡因子
	if (1 == bf)
	{
		psubr->bf = psubrl->bf = 0;
		parent->bf = -1;
	}
	else if (-1 == bf)
	{
		parent->bf = psubrl->bf = 0;
		psubr->bf = 1;
	}
	else if (0 == bf)
	{
		parent->bf = psubr->bf = psubrl->bf = 0;
	}
	else 
	{
		assert(false);
	}
}

四、总代码

#pragma once


#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;

template<class T, class V>
struct AVLN
{
	typedef pair<T, V> PTV;
	AVLN(const PTV& e)
		:parent(nullptr)
		,left(nullptr)
		,right(nullptr)
		,val(e)
		,bf(0)
	{}
	AVLN<T, V>* parent;
	AVLN<T, V>* left;
	AVLN<T, V>* right;
	PTV val;
	int bf;
};

template<class T, class V>
class AVL
{
	typedef pair<T, V> PTV;
	typedef AVLN<T, V> node;
public:
	AVL()
		:_root(nullptr)
	{}
	void insert(const PTV& val)
	{
		if (_root == nullptr)
		{
			node* tmp = new node(val);
			_root = tmp;
			return;
		}
		node* parent = _root;
		node* cur = _root;
		while (cur)
		{
			if (cur->val.first > val.first)
			{
				parent = cur;
				cur = cur->left;
			}
			else
			{
				parent = cur;
				cur = cur->right;
			}
		}
		cur = new node(val);
		if (parent->val.first > val.first)
		{
			parent->left = cur;
		}
		else
		{
			parent->right = cur;
		}
		cur->parent = parent;

		// 更新
		update(cur);
	}
	void RotateR(node* parent)
	{
		node* subl = parent->left;
		node* sublr = subl->right;

		parent->left = sublr;
		if (sublr)
			sublr->parent = parent;

		subl->right = parent;
		node* pparent = parent->parent;

		parent->parent = subl;

		if (_root != parent)
		{
			
			if (pparent->left == parent)
			{
				pparent->left = subl;
			}
			else 
			{
				pparent->right = subl;
			}
			subl->parent = pparent;
		}
		else
		{
			_root = subl;
			subl->parent = nullptr;
		}

		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;

		subr->left = parent;
		node* pparent = parent->parent;

		parent->parent = subr;

		if (_root != parent)
		{

			if (pparent->left == parent)
			{
				pparent->left = subr;
			}
			else 
			{
				pparent->right = subr;
			}
			subr->parent = pparent;
		}
		else
		{
			_root = subr;
			subr->parent = nullptr;
		}

		parent->bf = subr->bf = 0;
	}
	// 右左双旋
	void RotateRL(node* parent)
	{
		node* psubr = parent->right;
		node* psubrl = parent->left;
		int bf = psubrl->bf;

		RotateR(parent->right);
		RotateL(parent);

		if (1 == bf)
		{
			psubr->bf = psubrl->bf = 0;
			parent->bf = -1;
		}
		else if (-1 == bf)
		{
			parent->bf = psubrl->bf = 0;
			psubr->bf = 1;
		}
		else if (0 == bf)
		{
			parent->bf = psubr->bf = psubrl->bf = 0;
		}
		else 
		{
			assert(false);
		}
	}
	// 左右双旋
	void RotateLR(node* parent)
	{
		node* psubl = parent->left;
		node* psublr = psubl->right;

		int bf = psublr->bf;

		RotateL(parent->left);
		RotateR(parent);

		if (-1 == bf)
		{
			psubl->bf = psublr->bf = 0;
			parent->bf = 1;
		}
		else if (1 == bf)
		{
			parent->bf = psublr->bf = 0;
			psubl->bf = -1;	
		}
		else if (0 == bf)
		{
			parent->bf = psubl->bf = psublr->bf = 0;
		}
		else 
		{
			assert(false);
		}
	}
	void inorder()
	{
		_inorder(_root);
	}
	bool find(const PTV& val)
	{
		node* cur = _root;
		while (cur)
		{
			if (cur->val.first > val.first)
			{
				cur = cur->left;
			}
			else if (cur->val.first < val.first)
			{
				cur = cur->right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}
private:
	void _inorder(node* root)
	{
		if (root == nullptr) return;

		_inorder(root->left);
		cout << root->val.first << " " << root->val.second << endl;
		_inorder(root->right);
	}
void update(node* cur)
	{
		node* parent = cur->parent;

		while (parent)
		{
			if (parent->left == cur)
			{
				parent->bf -- ;
			}
			else
			{
				parent->bf ++ ;
			}
			
			if (parent->bf == 0) break; // 为0，不需要更新
			else if (parent->bf == 1 || parent->bf == -1)
			{
				cur = cur->parent;
				parent = cur->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(false);
			}
		}
	}
private:
	node* _root;

};

仍有未知等待探索
关注
专栏目录
C++ AVL树（高度平衡的二叉搜索树）
ChanJose的博客
03-25 659
一、思路 1.创建AVL树： 每次输入一个数num，然后用Insert()函数，将num插入到AVL树中。 // 创建AVL平衡树 template <class T> void AVLTree<T>::CreateAVLTree() { T num; cout << "请输入数（以-1结束输入）建立平衡二叉树...
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2776
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
c++写AVL二叉平衡搜索树算法
BlackCarDriver的博客
03-20 339
下面是我写的avl数算法模板，虽然已过三个月，现在再次想重写，仍然难以找到可以在优化的地方。 这个算法里面用到的递归操作和其他细节都很多，一旦某处写错，可能造成难以发现的bug。。。 下面是代码，注释照旧，发现不足之处或有所疑问欢迎留言。 #include<iostream> #include<stdio.h> #include<vector> #include...
C语言数据结构——平衡二叉树（AVL代码实现）
HSS521314的博客
09-18 294
【代码】C语言数据结构——平衡二叉树（AVL代码实现）
[C++系列] 77. 详解AVL平衡二叉搜索树
Y-puyu 的博客
02-10 789
文章目录1. AVL 树的概念2. AVL 树节点的定义3. AVL树的插入与失衡4. AVL树的旋转4.1 新节点插入较高左子树的左侧---左左：右单旋4.2 新节点插入较高右子树的右侧---右右：左单旋4.3. 新节点插入较高左子树的右侧---左右：先左单旋再右单旋4.4. 新节点插入较高右子树的左侧---右左：先右单旋再左单旋5. AVL树旋转总结：6. AVL树的实现7. AVL树的验证7...
平衡二叉树(AVL树) ----- C语言
Snow Yong
12-18 3139
前面说到了二叉搜索树，它在动态查找表中有较高的性能，既能保证在无序数据中查找的高效率，又相对于数组具有方便的增添删除功能， 其平均查找复杂度为所构造的二叉树的树高，即O(logn)( 图1 )，但是，对于极端情况，例如该二叉树是一颗左斜树或者右斜树 (图2) 。 此时，显然可以看到，最坏查找时间复杂度为O(n)，这就意味着我们的二叉搜索树变成了顺序查找，效率极为低下，所以我们需要一种 平衡二
【二叉树进阶】红黑树（Red Black Tree） - 平衡二叉搜索树
codewinter的博客
06-21 3402
红黑树，是一种平衡二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是 Red 或 Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。AVL树和红黑树：红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于AVL树，使得红黑树整体性能略优于AVL树，不然map和set底层怎么会用红黑树呢，包括很多语言的库里面都用了红黑树。如果发明AVL树的人是天才的话，那么发明红
【进阶数据结构】二叉搜索树&经典习题讲解
East-sunrise的博客
03-20 1088
二叉搜索树 —— 轻易找到你想要的
C++进阶——AVL树
weixin_51885188的博客
03-08 1361
文章目录C++进阶——AVL树AVL树的概念AVL树的实现AVL树节点的定义AVL树的四个默认成员函数构造函数拷贝构造析构函数赋值运算符重载AVL树的插入插入的步骤平衡因子的调节旋转处理（父节点的平衡因子违法平衡树的性质）代码实现[]运算符的重载AVL树的查找AVL树的打印验证是否为AVL树AVL树代码实现 C++进阶——AVL树 AVL树的概念 在前面的文章中我们学习了二叉搜索树，但是二叉搜索树虽然可以缩短查找的效率，但是 如果数据有序或者接近有序的情况下二叉搜索树会退化成单支树，查找元素相当于在顺序表中
【二叉搜索树进阶】：平衡增长的优雅实现技巧
二叉搜索树（BST）是一种特殊的二叉树，它不仅能够存储数据，还能高效地执行数据的插入、查找和删除操作。其核心是每个节点都遵循这样的规则：对于任意节点N，其左子树上的所有节点的值都小于等于N的值，而其右子树...
C++中set的用法
weixin_34413065的博客
03-27 509
set的特性是，所有元素都会根据元素的键值自动排序，set的元素不像map那样可以同时拥有实值(value)和键值(key),set元素的键值就是实值，实值就是键值。set不允许两个元素有相同的键值。 set的各成员函数列表如下: 1. begin()--返回指向第一个元素的迭代器 2. clear()--清除所有元素 3. count()--返回某个值元素的个数 4. empty()-...
平衡二叉树（c++）
photoresist的博客
03-10 803
平衡二叉树定义平衡二叉树类二叉树的调整右单旋左单旋左右双旋插入删除操作完整代码 定义 平衡树(Balance Tree，BT) 指的是，任意节点的子树的高度差都小于等于1。常见的符合平衡树的有，B树（多路平衡搜索树）、AVL树（二叉平衡搜索树）等。平衡树可以完成集合的一系列操作, 时间复杂度和空间复杂度相对于“2-3树”要低，在完成集合的一系列操作中始终保持平衡，为大型数据库的组织、索引提供了一条新的途径 平衡二叉树类 继承二叉树类 二叉树类代码（GitHub）：https://github.com/r
C++实现平衡搜索树
qingdou_aixuexi的博客
09-21 1900
AVL树 左子树和右子树的高度之差不超过1左子树和右子树都是AVL树 平衡因子=右子树个数-左子树 #define _CRT_SECURE_NO_WARNINGS 1 #include #include using namespace std; template struct AVLTreeNode { K _key; V _value; AVLT
2411C++,C++26反射示例
个人进步之路
11-13 979
2411C++,C++26反射示例
C++中的 std::optional
万里归来少年心
11-17 177
std::optional是C++17中的一个标准库组件，optional 对象默认是空的，也就是处于无效状态，给它赋值后因为里面有了元素，就变成了有效状态。
C/C++基础知识复习（23）
m0_72883750的博客
11-17 383
某些类型转换可能会引发未定义行为，尤其是使用或const_cast时。如果转换不合理或对原数据结构产生不正确的操作，可能会导致程序崩溃或者出现奇怪的运行时错误。int x = 10;// 错误的类型转换，可能导致程序崩溃或未定义行为。
c语言基础知识点（十五）C语言中的指针+1与指针的二进制表示+1的区别
qq_51519091的博客
11-13 365
给一个指针加上一个整数与给该指针的二进制表示加上同样的整数，这两者之间存在本质的区别，主要体现在操作对象、操作意义以及结果上。
Cross-Inlining Binary Function Similarity Detection
最新发布
Che_Che_的博客
11-17 515
编译器在编译时将函数调用直接替换为函数体代码，从而消除函数调用的开销。代码直接嵌入到调用点，而不是通过函数调用进行。这可以减少函数调用的开销。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

仍有未知等待探索

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值