保姆级认识AVL树【C++】（三种insert情况 || 四种旋转方法）

于 2024-03-10 16:42:38 发布
阅读量1k 收藏 25
点赞数 22
分类专栏： C++——从入门到入土，安排！ 文章标签： 算法 1024程序员节 c++ 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72112924/article/details/133997283
版权

目录

前言

一，AVL概念

二，基础框架

三，insert

1. 插入三种情况

2. 四种旋转方法

法一：左单旋法

法二：右单旋法

法三：先左后右双旋法

法四：先右后左双旋法

测试（判断一棵树是否是AVL树）

代码如下：

3. 随机值案例

insert全代码

四，删除

下期预告： 红黑树！！！

结语

嗨！收到一张超美的风景图，愿你每天都能顺心！

前言

map,set这两个容器有个共同点是： 其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。

搜索二叉树请查看本篇博文：【C++】搜索二叉树底层实现_花果山~程序猿的博客-CSDN博客

一，AVL概念

二叉搜索树虽可以缩短查找的效率，但 如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年发明了一种解决上述问题的方法： 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
1. 它的左右子树都是AVL树
2. 左右子树高度之差(简称平衡因子)的绝对值不超过 1  (-1/0/1) （AVL树不一定用平衡因子进行实现）
如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 O(log_2 n)，搜索时间复杂度O(log_2 n)。

二，基础框架

为方便循序渐进的学习，这里只放最出初始的树结点定义。

template <class K, class V>
class AVL_Data
{
public:
	pair<K, V> _kv;
	AVL_Data<K, V>* left = nullptr;
	AVL_Data<K, V>* right = nullptr;
	AVL_Data<K, V>* parent = nullptr;
	int _bf = 0; // ballance factor

	AVL_Data(const pair<K, V>& p)
		:_kv(p)
	{}

};

上面定义在后面会进行完善修改。

三，insert

根据前面搜索二叉树的经验我们能快速写完插入函数，但AVL树是特殊的搜索二叉树，我们需要对树的高度进行调整。那么我们插入时就会遇到三种情况：

1. 插入三种情况

情况一：

情况二：

情况三：

代码实现如下：

template <class K, class V>
class AVL_Tree
{
	typedef AVL_Data<K, V>  AVL_Data;

	AVL_Data* root = nullptr;

public:
	bool insert(const pair<K, V>& p)
	{
		AVL_Data* new_a_d = new AVL_Data(p);
		if (!root)
		{
			root = new_a_d;
		}
		else
		{
			AVL_Data* cur = root;
			AVL_Data* parent = nullptr;
			while (cur)
			{
				if (p.first < cur->_kv.first)
				{
					parent = cur;
					cur = cur->left;
				}
				else if (p.first > cur->_kv.first)
				{
					parent = cur;
					cur = cur->right;
				}
				else
				{
					delete(new_a_d); // 插入失败，删除新建结点
					return false;
				}
			}

			if (p.first < parent->_kv.first)
			{
				parent->left = new_a_d;
			}
			else
			{
				parent->right = new_a_d;
			}
			new_a_d->parent = parent;

			cur = new_a_d;
			//完成插入，进行平衡
			while (parent)
			{   // 插入，修改parent平衡因子
				if (cur == parent->right)
				{
					parent->_bf++;
				}
				else
				{
					parent->_bf--;
				}

				// 判断parent平衡因子是否是0，如果非0则需要向祖先更新平衡因子
				if (parent->_bf == 1 || parent->_bf == -1)
				{
					cur = parent;
					parent = parent->parent;
				}
				else if (parent->_bf == 0)
				{
					break;
				}
				else if(parent->_bf == 2 || parent->_bf == -2)
				{ 
					// 处理绝对值大于1,下面代码目的是记录未修改的平衡因子。
					// 需要旋转处理，这个我们下面再讲
					cur = parent;
					parent = parent->parent;
				}
				else
				{
					// 出现其他情况，在插入时这棵AVL树本身就是异常AVL树
					assert(false);
				}
			}
			return true;
		}
		
	}
};

2. 四种旋转方法

法一：左单旋法

我们以下面图为讲解例子，a,b,c表示的是子树。

h 表示子树的高度。

 请看下面场景:

h = 3, 4...组合方式会更多，这里画出图没什么意义，问题是失去平衡我们如何解决？？ 

通过下面方法解决：

总结：

1. 右边高，则向左旋转。

2. C树发生插入，平衡因子发生改变，进而发生旋转。

void RotateL(AVL_Data* parent)
	{
		assert(parent->right);
		AVL_Data* par = parent;
		AVL_Data* par_R = par->right;
		AVL_Data* par_RL = par->right->left;
		AVL_Data* ppnode = par->parent;

		par->right = par_RL;
		if (par_RL)
		par_RL->parent = par;

		par_R->left = par;
		par->parent = par_R;
		par_R->parent = ppnode;

		if (!ppnode)
		{
			root = par_R;
		}
		else if (ppnode->left == par)
		{
			ppnode->left = par_R;
		}
		else
		{
			ppnode->right = par_R;
		}
		
		par->_bf = 0;
		par_R->_bf = 0;
	}

// 实验例子
    AVL_Tree<int, string> tree;
	tree.insert(make_pair(30 , "李四"));
	tree.insert(make_pair(20, "二麻子"));
	tree.insert(make_pair(60, "张三"));
	tree.insert(make_pair(45, "王五"));
	tree.insert(make_pair(75, "王五"));
	tree.insert(make_pair(65, "王五"));

法二：右单旋法

思路跟左旋法差不多，图像是相反，这里就只给场景解法模板：

h = 0, 1, 2的发生场景：

学会了法一自然会了法二：

void RotateR(AVL_Data* parent)
	{
		assert(parent->left);
		AVL_Data* par = parent;
		AVL_Data* par_L = par->left;
		AVL_Data* par_LR = par->left->right;
		AVL_Data* ppnode = par->parent;

		par->left = par_LR;
		if (par_LR)
			par_LR->parent = par;

		par_L->right = par;
		par->parent = par_L;
		par_L->parent = ppnode;

		if (!ppnode)
		{
			root = par_L;
		}
		else if (ppnode->left == par)
		{
			ppnode->left = par_L;
		}
		else
		{
			ppnode->right = par_L;
		}

		par->_bf = 0;
		par_L->_bf = 0;
	}

法三：先左后右双旋法

跟单旋一样，我们首先展示，当h = 0，1，2时需要左右双旋处理的场景。

双旋法步骤变化流程，如下：

从结果来看，就是将60这个位置推上去置于“根”。

代码如下：

void RotateLR(AVL_Data* parent)
	{
		assert(parent->left);
		AVL_Data* par = parent;
		AVL_Data* par_L = par->left;
		AVL_Data* par_LR = par->left->right;
		AVL_Data* ppnode = par->parent;

		int par_LR_bf = par_LR->_bf;

		RotateL(par_L);
		RotateR(par);

		if (par_LR_bf == -1)
		{
			par->_bf = 1;
			par_L->_bf = 0;
		}
		else if (par_LR_bf == 1)
		{
			par->_bf = 0;
			par_L->_bf = -1;
		}
		else if (par_LR_bf == 0)
		{
			par->_bf = 0;
			par_L->_bf = 0;
		}
		else
		{
			assert(false);
		}
		par_LR->_bf = 0;
	}

// 测试案例
void Test_insert_L()
{
	AVL_Tree<int, string> tree;
	tree.insert(make_pair(90, "李四"));
	tree.insert(make_pair(30, "二麻子"));
	tree.insert(make_pair(100, "张三"));
	tree.insert(make_pair(25, "王五"));
	tree.insert(make_pair(60, "王五"));
	tree.insert(make_pair(50, "王五"));
}

法四：先右后左双旋法

我们学会法三后，照葫芦画瓢即可。

各场景： 

代码：

void RotateRL(AVL_Data* parent)
	{
		assert(parent->right);
		AVL_Data* par = parent;
		AVL_Data* par_R = par->right;
		AVL_Data* par_RL = par->right->left;
		AVL_Data* ppnode = par->parent;

		int par_RL_bf = par_RL->_bf;

		RotateR(par_R);
		RotateL(par);

		if (par_RL_bf == -1)
		{
			par->_bf = 0;
			par_R->_bf = 1;
		}
		else if (par_RL_bf == 1)
		{
			par->_bf = -1;
			par_R->_bf = 0;
		}
		else if (par_RL_bf == 0)
		{
			par->_bf = 0;
			par_R->_bf = 0;
		}
		else
		{
			assert(false);
		}
		par_RL->_bf = 0;
	}

// 测试案例
void Test_insert_L()
{
	AVL_Tree<int, string> tree;
	tree.insert(make_pair(30, "李四"));
	tree.insert(make_pair(20, "二麻子"));
	tree.insert(make_pair(90, "张三"));
	tree.insert(make_pair(15, "王五"));
	tree.insert(make_pair(60, "王五"));
	tree.insert(make_pair(100, "王五"));
	tree.insert(make_pair(55, "王五"));
	tree.insert(make_pair(67, "王五"));
	tree.insert(make_pair(95, "王五"));
	tree.insert(make_pair(50, "王五"));
}

测试（判断一棵树是否是AVL树）

思路：

1.  检查高度（AVL中每棵子树都是AVL树）。

2.  检查平衡因子是否正确。

代码如下：

    int Hight(const AVL_Data* root)
	{
		if (root == nullptr)
			return 0;

		int left_H = Hight(root->left);
		int left_R = Hight(root->right);
		return left_H >= left_R ? left_H + 1 : left_R + 1;
	}

    bool B_balance()
	{
		return _B_balance(root);
	}
	
	bool _B_balance(const AVL_Data* root)
	{
		if (root == nullptr)
			return true;
		int left_root = Hight(root->left);
		int right_root = Hight(root->right);


		if ((right_root - left_root) != root->_bf) // 利用Hight，进行平衡因子判断
			return false; 

		return abs(left_root - right_root) < 2 && _B_balance(root->left) && _B_balance(root->right);
	}

3. 随机值案例

用这个代码多跑几次，差不多能遍历所有环境。

void Random_Test()
{
	srand(time(0));
	const size_t N = 10000000;
	AVL_Tree<int, int> t;
	for (size_t i = 0; i < N; i++)
	{
		size_t x = rand();
		t.insert(make_pair(x, x));
	}

	cout << t.B_balance() << endl;
}

快来测试自己的代码吧

insert全代码

bool insert(const pair<K, V>& p)
	{
		AVL_Data* new_a_d = new AVL_Data(p);
		if (!root)
		{
			root = new_a_d;
		}
		else
		{
			AVL_Data* cur = root;
			AVL_Data* parent = nullptr;
			while (cur)
			{
				if (p.first < cur->_kv.first)
				{
					parent = cur;
					cur = cur->left;
				}
				else if (p.first > cur->_kv.first)
				{
					parent = cur;
					cur = cur->right;
				}
				else
				{
					delete(new_a_d); // 插入失败，删除新建结点
					return false;
				}
			}

			if (p.first < parent->_kv.first)
			{
				parent->left = new_a_d;
			}
			else
			{
				parent->right = new_a_d;
			}
			new_a_d->parent = parent;

			cur = new_a_d;
			//完成插入，进行平衡
			while (parent)
			{   // 插入，修改parent平衡因子
				if (cur == parent->right)
				{
					parent->_bf++;
				}
				else
				{
					parent->_bf--;
				}

				// 判断parent平衡因子是否是0，如果非0则需要向祖先更新平衡因子
				if (parent->_bf == 1 || parent->_bf == -1)
				{
					cur = parent;
					parent = parent->parent;	
				}
				else if (parent->_bf == 0)
				{
					break;
				}
				else if (parent->_bf == -2 || parent->_bf == 2)
				{
					if (parent->_bf == 2 && cur->_bf == 1)
					{
						RotateL(parent);
						// cout << "RotateL" << endl;
					}
					else if (parent->_bf == -2 && cur->_bf == -1)
					{
						RotateR(parent);
						// cout << "RotateR" << endl;
					}
					else if (parent->_bf == -2 && cur->_bf == 1)
					{
						RotateLR(parent);
						// cout << "RotateLR" << endl;
					}
					else if (parent->_bf == 2 && cur->_bf == -1)
					{
						RotateRL(parent);
						// cout << "RotateRL" << endl;
					}
					else
					{
						// 出现其他情况，在插入时这棵AVL树本身就是异常AVL树
						// 问题出现在旋转方法
						assert(false);
					}
					break;
				}
				else
				{
					assert(false);
				}
			}
			return true;
		}
	}

四，删除

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不 错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。 具体实现学生们可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

下期预告： 红黑树！！！

结语

   本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力。

花果山~程序猿
关注
  • 22
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
AVL树的四种旋转方式(详细图解)
qq_65786321的博客
11-09 889
新节点插入到左子树的右侧时对parent使用左右双旋。新节点插入到右子树的左侧时对parent使用右左双旋。新节点插入到右子树的右侧时对parent使用左单旋。新节点插入到左子树的左侧时对parent使用右单旋。
AVL树的旋转
d_CSDNW的博客
07-10 257
···AVL树又称为高度平衡的二叉树。它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度。 ···AVL树有以下几条性质： ·····1.左子树和右子树的高度之差的绝对值不超过1 ·····2.树中的每个左子树和右子树都是AVL树 ·····3.每个节点都有一个平衡因子，任一节点的平衡因子是-1，1，0.（每个节点的平衡因子等于右子树的高度减去左子树的高度） ·...
avl.rar_AVL树_avl 旋转_树 旋转
09-24
在"avl.rar"压缩包中的"main.cpp"文件，很可能是实现了一个AVL树的C++程序，包括查找、删除以及上述四种旋转操作的代码。通过直接运行这个程序，我们可以观察和理解AVL树的各种操作是如何在实际中执行的。查找操作...
AVL树 C++ 实现
03-05
AVL树是一种自平衡二叉查找树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。它的主要特性是任何节点的两个子树的高度差不超过1，这使得AVL树在插入和删除操作后能够快速恢复平衡，从而保持...
AVL树的c++实现
08-03
AVL树是一种自平衡二叉查找树，它的主要特性是任何节点的两个子树的高度最大差别不超过1，这使得AVL树在查找、插入和删除等操作上的效率相对较高，平均时间复杂度为O(log n)。在C++中实现AVL树，我们可以利用模板类...
基于C++ AVL树的航空客运订票系统【100012693】
最新发布
06-12
在C++中，AVL树的实现需要定义节点结构，包含键值、高度、指向左右子节点的指针，以及用于调整平衡的旋转操作（左旋和右旋）。 在该航空订票系统中，AVL树被用来存储航班记录。每个航班记录包含航班号、起飞和降落...
关于AVLTree（C++实现）没有统一旋转操作的问题
08-25
AVL树的旋转操作可以分为四种情况：LL、LR、RR和RL。其中，LL和RR表示左左和右右旋转，LR和RL表示左右和右左旋转。 三、AVL树的实现 AVL树的实现可以使用C++语言来实现。下面是一个使用C++11标准实现的AVL树代码...
~AVL树中的旋转~
眼与泪的诀别的博客
04-04 368
~AVL树中的旋转~
平衡树之AVL树旋转
Holy_Spirit
03-31 576
大一就学了数据结构，当听到AVL树的时候就很蒙，也没认真。最近开始认真看，那书上讲的何止是蒙，讲的我是莫名其妙。不知道为什么那么多人喜欢严蔚敏版的数据结构，没觉得好在哪里，讲的少，讲的粗略，讲的也是莫名其妙。可能是我的问题把，所以在网上搜了相关资料的，我一直认为，一个理论要马上接收，其实挺难的，我的做法是先不管那么多，掌握基本的操作就行，在你每次用的过程中，总会关心到某些值得推敲的地方，这样的抛砖
数据结构——AVL树旋转
MDeleter的博客
02-18 796
AVL树是一颗二叉查找树，需要逻辑规则来检查并修正可能出现的不平衡。 package TreePackage; public class AVLTree<T extends Comparable<? super T>> extends BinarySearchTree<T> implements SearchTreeInterface<T> { public AVLTree() { super();
AVL树的旋转操作
zhuqi7的博客
09-16 406
PAT Advanced Level 1066题涉及到了AVL树的元素插入，插入后需要进行旋转操作 在此转载 http://blog.csdn.net/collonn/article/details/20128205 和 http://dongxicheng.org/structure/avl/ 两篇文章整理AVL树的几种旋转操作 AVL树的基本数据结构： typedef struct
AVL树的旋转详解
半暖的博客
03-30 370
       二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素也就相当于是在顺序表中搜索元素，效率低下。因此，为了解决二叉搜索树中单支树的这种情况，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了AVL（平衡树）：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差(平衡因子)的绝对值不超过1(...
数据结构期末复习——二叉平衡树（AVL树）的旋转
qq_39561693的博客
06-19 238
平衡树 要记得计算平衡因子。平衡因子为当前节点为根节点的子树的左右子树高度差。 插入、删除都会改变平衡因子。顺着操作的节点向上找到第一个平衡因子大于1的节点，经过的路径即为最小不平衡子树。最小不平衡子树最多只有3个节点。通过如下的旋转可以达到平衡的目的： 单旋 最简单的情况是，子树呈一条直线。 将中间的“拎起来”即可。 双旋 由于搜索树的性质，当不平衡子树出现“弯折”时，直接将中间的“拎起来”会破坏搜索树“左小右大”的性质。此时通过交换，将3个节点中大小处在中间的节点放到中间的位置，再由“左小右大”的性
AVL树旋转图示
希望大家一起快乐的学java
07-23 182
AVL树是平衡二叉树,本质上是一棵二叉查找树 特点:它的左右两个子树的高度差绝对值不超过1,并且左右两个子树都是一棵平衡二叉树. 插入操作 AVL树不仅是一棵二叉查找树,它还有其他性质,按照一般二叉查找树的插入方式可能会破坏AVL树的平衡性,所以在插入结点时,为了保证AVL的平衡性,我们进行了旋转操作: 左旋;插入的结点位于根结点的右子结点上 右旋;插入的结点位于根结点的左子结点上 ...
【平衡二叉搜索树（AVL）-- 旋转】
m0_熊猫馆主的博客
05-01 1512
打怪升级：第60天旋转是为了在保持平衡树性质的前提下降低树的高度，右子树高AVLTree，也就是我们所说的：自平衡二叉搜索树，AVL命名由来是两位发明者的名字的首字母，并无其他含义。AVL树是一棵搜索树；AVL树左右子树的高度差的绝对值不大于1；AVL树的左右子树也是AVL树。高度差可取0,1,-1。注：我们将左右子树的高度差称为平衡因子，简称为bf既然AVL树是一棵搜索树它就需要满足搜索树的特征：左子树不空，左子树上的值都小于根节点的值；右子树不空，右子树上的值都大于根节点的值；左右子树也都是二叉搜索树。
AVL树C++实现详解：包含栈队列与自平衡操作
本文档提供了AVL树在C++中的详细实现，包括AVL树类（AVL）的定义、方法以及与基本数据结构如队列（AbsQueue）和标准二叉搜索树（BST）的关联。 首先，我们来看一下基础的队列抽象类AbsQueue，它提供了一些基本操作...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值