map和set(二)——AVL树的简单实现

已于 2024-03-10 20:19:56 修改
阅读量973 收藏 30
点赞数 17
文章标签： c++ 开发语言
于 2024-03-10 20:19:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74515566/article/details/136578756
版权
本文详细介绍了AVL树的概念，如何在二叉搜索树基础上通过平衡因子实现平衡，包括插入操作中的调整策略和四种旋转类型，以及如何判断一棵树是否为AVL树。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

引入

二叉搜索树有其自身的缺陷，假如往树中 插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此 map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。简单来说就是之前二叉搜索树由于可能在某一个节点上一直深入，按照最坏情况算这的时间复杂度就高了起来，而AVL树这其中之一的平衡树

1.AVL树的概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查 找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均 搜索长度

AVL树又称高度平衡二叉搜索树

任何AVL树都满足一下条件:

  • 它的左右子树都是AVL树
  • 任何树及其子树的高度差(也就是平衡因子)的绝对值不超过1

 比如：

当然平衡因子不一定是必须的，它只是一种控制方式(让我们更便捷地控制这棵树) 

为何是不超过1，而不是0呢？0不是更加平衡吗？

由于树的节点是一个个插入的，无法保证绝对的平衡(有些情况无法满足高度差为0)；因此高度差不超过1

2.AVL树节点的定义

和二叉搜索树类似，只不过多了个平衡因子

//AVL树的节点
template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K,V>* _left;
	AVLTreeNode<K,V>* _right;
	AVLTreeNode<K,V>* _parent;
	int _bf = 0;//平衡因子
	pair<K, V> _kv;

	//构造
	AVLTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
		, _kv(kv)
	{}

};

3.AVL树的插入

3.1插入

AVL树就是在二叉搜索树的基础上引进了平衡因子(bf)，因此AVL树也可以看做二叉搜索树

AVL树的插入过程可以分为两步:

  1. 以二叉搜索树的方式插入新节点
  2. 调整节点的平衡因子

二叉搜索树的方式插入 

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 (kv.first > cur->_kv.first)//插入的值比遍历的值大
			{
				parent = cur;//cur往下遍历时，父节点同时要往下走
				cur = cur->_right;//往右走
			}
			else if (kv.first < cur->_kv.first)//插入的值比遍历的值小
			{
				parent = cur;
				cur = cur->_left;//往左走
			}
			else//说明插入的值已经存在，return false
			{
				return false;
			}

		}
		//走到这说明已经找到可以插入的地方 
		//创建一个新节点
		cur = new Node(kv);
		//判断插入的节点该连接到父节点的左还是右
		if (cur->_kv.first > parent->_kv.first)//cur 的值大于父节点的值，连右
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		//接下来就是判断平衡因子的时候了
		return true;
	}

 判断平衡因子

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

插入节点会影响哪些节点的平衡因子呢？新增节点的部分祖先

更新原则：

若cur是此父节点的左子树(节点)那么父节点的平衡因子-- ，是右子树(节点)那么父节点平衡因子++

是否继续更新取决于父节点的高度是否变化，是否会影响爷爷节点
一直往上走直至parent为nullptr(根节点的父节点为空)或者平衡因子为0或者平衡因子为2(需要旋转)

当cur(新增节点插入后)，有三种情况

情况1：

更新后 父节点(parent)的平衡因子(bf)为 0 ，parent所在子树高度不变，不会影响爷爷；说明更新前parent的bf为1或-1，往父节点矮的那边插入节点，左右均衡，parent所在子树的高度不变

情况2：

更新后 父节点的平衡因子为1或-1，parent所在子树高度改变了，会影响爷爷，继续往上更新；说明更新前parent的bf为0(本身平衡了)，往p的任意一边插入，使父节点变得不均衡，但不违反规则

情况3：

更新后父节点的平衡因子为2或-2，说明父节点所在的子树违反了平衡规则，需要旋转处理

		//接下来就是判断平衡因子的时候了
		cur->_parent = parent;
		while (parent)
		{
			if (cur == parent->_left)//cur在父左 父bf--
			{
				parent->_bf--;
			}
			else//cur在父右 父bf++
			{
				parent->_bf++;
			}
			if (parent->_bf == 0)//父bf==0 break
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)//父bf为1 or -1继续往上
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_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)//两边都高左右双旋
				{
					RotateLR(parent);
				}
				else//右左双旋
				{
					RotateRL(parent);
				}
			}
			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 (kv.first > cur->_kv.first)//插入的值比遍历的值大
			{
				parent = cur;//cur往下遍历时，父节点同时要往下走
				cur = cur->_right;//往右走
			}
			else if (kv.first < cur->_kv.first)//插入的值比遍历的值小
			{
				parent = cur;
				cur = cur->_left;//往左走
			}
			else//说明插入的值已经存在，return false
			{
				return false;
			}

		}
		//走到这说明已经找到可以插入的地方 
		//创建一个新节点
		cur = new Node(kv);
		//判断插入的节点该连接到父节点的左还是右
		if (cur->_kv.first > parent->_kv.first)//cur 的值大于父节点的值，连右
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		//接下来就是判断平衡因子的时候了
		cur->_parent = parent;
		//若cur是此父节点的左子树(节点)那么父节点的平衡因子-- ，是右子树(节点)那么父节点平衡因子++
		//一直往上走直至parent为nullptr(根节点的父节点为空)或者平衡因子为0或者平衡因子为2(需要旋转)
		while (parent)
		{
			if (cur == parent->_left)//cur在父左 父bf--
			{
				parent->_bf--;
			}
			else//cur在父右 父bf++
			{
				parent->_bf++;
			}
			if (parent->_bf == 0)//父bf==0 break
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)//父bf为1 or -1继续往上
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_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)//两边都高左右双旋
				{
					RotateLR(parent);
				}
				else//右左双旋
				{
					RotateRL(parent);
				}
			}
			else
			{

				assert(false);
			}
		}
		return true;
	}

3.2旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：左单旋、右单旋、左右双旋以及右左双旋

左单旋——新节点插入较高右子树的右侧---右右

void RotateL(Node* parent)//左单旋
	{
		//sub是parent ，subR是parent的右节点，subRL是subR的左节点
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;//父节点的右节点指向subRL
		//subRL可能为空节点，也就是这颗树(子树)只有sub(parent节点)、subR、以及新增节点这三个节点 如果subRL为空，就不用将其父节点指向sub了
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		parent->_parent = subR;//把父节点的父节点指向subR
		//父节点(sub)有可能是一颗树(子树)的根节点 
		//如果(sub)是一颗树的根节点的话 subR直接为根节点，subR的parent直接是空
		if (parent = _root)
		{
			subR = _root;
			subR->_parent = nullptr;
		}
		else//sub是一颗子树的根节点 
		{
			//得看sub是其父节点的左节点还是右节点
			//然后subR连接sub的父节点
			if (parent == ppnode->_left)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
		//sub和subR平衡因子置为0
		subR->_bf = 0;
		parent->_bf = 0;

	}

右单旋——新节点插入较高左子树的左侧---左左

//右单旋思路和左单旋差不多
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subL;
		if (parent == _root)
		{
			subL = _root;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == ppnode->_left)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
		subL->_bf = 0;
		parent->_bf = 0;
	}

左右双旋—— 新节点插入较高左子树的右侧---左右(先左单旋再右单旋)

左右两边都高单旋解决不了问题

//左右双旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		//subLR的平衡因子不同时对其它节点的平衡因子的改变也不同
		int bf = subLR->_bf;

		RotateL(parent->_left);//先走左单旋
		RotateR(parent);//再走右单旋

		if (bf == -1)//若subLR的bf为-1，则新增节点是subLR的左子树
		{
			subLR->_bf = 0;
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)//若subLR的bf为1，则新增节点是subLR的右子树
		{
			subLR->_bf = 0;
			subL->_bf = -1;
			parent->_bf = 0;
		}
		else if (bf == 0) //若subLR的bf为0,那么subLR其本身就是新增节点
		{
			subLR->_bf = 0;
			subL->_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(subR);
		RotateL(parent);
		if (bf == -1)
		{
			subRL->_bf = 0;
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subRL->_bf = 0;
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 0)
		{
			subRL->_bf = 0;
			subR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

 4.判断是否为AVL树

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

1. 验证其为二叉搜索树 如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_kv.first << "[" << root->_bf << "]" << endl;
		_Inorder(root->_right);
	}

	void Inorder()
	{
		_Inorder(_root);
	}

2. 验证其为平衡树 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子) 节点的平衡因子是否计算正确

	int _Height(Node* root)
	{
		if (root == nullptr)
			return;
		int leftHight = Height(root->_left);
		int rightHight = Height(root->_right);
		return leftHight > rightHight ? leftHight + 1 : rightHight + 1;

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

	bool _IsAVLTree(Node* root)
{
	if (root == nullptr)
	{
		return true;
	}
	
	int leftHeight = Height(root->_left);

	int	rightHeight = Height(root->_right);

	if (abs(leftHeight - rightHeight) >= 2)
	{
		cout << "不平衡" << endl;
		return false;
	}
	if (rightHeight - leftHeight != root->_bf)
	{
		cout << root->_kv.first << "平衡因子异常" << endl;
		return false;
	}
	return _IsAVLTree(root->_left)&&_IsAVLTree(root->_right);
}
	bool IsAVLTree()
	{
		return _IsAVLTree(_root);
	}

如果走前序递归的话计算高度和前序递归会存在大量重复，所以还是走后序的同时求高度

后序先走左子树判断平衡返回高度；再走右子树判断平衡返回高度

bool _IsAVLTree(Node* root, int& height)
	{
		if (root == nullptr)
		{
			height = 0;
			return true;
		}
		//走个后序
		int leftHeight, rightHeight = 0;
		if (!_IsAVLTree(root->_left, leftHeight) || !_IsAVLTree(root->_right, rightHeight))
		{
			return false;
		}
		if (abs(leftHeight - rightHeight) >= 2)
		{
			cout << "不平衡" << endl;
			return false;
		}
		if (rightHeight - leftHeight != root->_bf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}

		height = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;

		return true;
	}
	bool IsAVLTree()
	{
		int height = 0;
		return _IsAVLTree(_root, height);
	}

set 模拟平衡树解题
好久不见
08-11 1973
例． 营业额统计(湖南选拔赛） [问题描述] 公司的账本上记录了公司成立以来每天的营业额。分析营业情况是一项相当复杂的工作,营业额会出现一定的波动，当然一定的波动是能够接受的，但是在某些时候营业额突变得很高或是很低，这就证明公司此时的经营状况出现了问题。经济管理学上定义了一种最小波动值来衡量这种情况： 该天的最小波动值 = min{ |  改天以前某天的营业额  - 当天的营业额  | }
详解set/map的底层结构——AVL树和红黑树
zcxmjw的博客
05-12 1334
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。AVL树的规则如下1.它的左右子树都是AVL树2.左右子树高度之差(这里我们简称为平衡因子)的绝对值不超过1如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在logN，搜索时间复杂度logN。
【数据结构】AVL树(图文解析 + 代码实现)
2301_80277275的博客
07-23 3289
AVL树的概念、AVL树结点的定义、AVL树的插入、AVL树的旋转、AVL树的验证
平衡树（STL set）
hwdn3000的博客
10-16 1632
C++ STL 之所以得到广泛的赞誉，也被很多人使用，不只是提供了像vector, string, list等方便的容器，更重要的是STL封装了许多复杂的数据结构算法和大量常用数据结构操作。vector封装数组，list封装了链表，map和set封装了二叉树等，在封装这些数据结构的时候，STL按照程序员的使用习惯，以成员函数方式提供的常用操作，如：插入、排序、删除、查找等。让用户在STL使用过程中，并不会感到陌生。 关于set，必须说明的是set关联式容器。set作为一个容器也是用来存储同一数据类型的数据类
平衡二叉搜索树---红黑树（SET容器的由来）
weixin_42145502的博客
07-27 197
https://blog.youkuaiyun.com/qq_35469756/article/details/79188118（平衡二叉搜索树原理） https://blog.youkuaiyun.com/sinat_37158899/article/details/79328104（容器set应用） set是STL中一种标准关联容器。它底层使用平衡的搜索树——红黑树实现，插入删除操作时仅仅需要指针操作节点即可完成...
普通平衡树
Ren_Ivan的博客
09-24 381
SPLAY#include<cstdio> #include<iostream> #include<cstring> #define N 1000005 using namespace std; int ch[N][2],f[N],size[N],cnt[N],key[N],root,sz; inline void clear(int x){ ch[x][0]=ch[x][1]=f[x]=siz
STL容器之map和set的补充——AVL树
qq_33093885的博客
03-05 1190
AVL树的原理以及模拟实现
从零开始的c++之旅——AVL树及其实现
2302_81813630的博客
12-08 1407
旋转核⼼步骤，因为5<b⼦树的值<10,将b变成10的左⼦树，10变成5的右⼦树，5变成这棵树新 的根，符合搜索树的规则，控制了平衡，同时这棵的⾼度恢复到了插⼊之前的h+2，符合旋转原 则。（类似我们之前说的map容器）这里我们可以得知，插入节点的位置回导致subLR这颗子树的平衡因此的变化，上述三种情况会导致插入后subLR的平衡因子各不相同，因此我们在双旋之前记录下其平衡因子，在旋转之后通过对其平衡因子的判断从而得知平衡因子的更新路径。需要明确的是，插入前的这颗AVL树是一个完整的符合规则的AVL树。
STL容器之map和set的补充——红黑树
qq_33093885的博客
03-06 1139
c++红黑树的学习和模拟实现
map和set的底层结构——红黑树
大学生一枚
07-30 628
RED,BLACK, _kv(kv){}红黑树多了储存颜色的功能；而且红黑树插入节点是默认插入红色的节点，因为如果插入黑色节点，必定破坏规则4，而插入红节点，可能破坏规则三，可能出现两个连续的红色节点，但是可以修改，也有可能插入红色节点，刚好满足条件，所以我们选择插入默认是红色的节点；
平衡树专题训练
HeartWine的博客
10-27 173
题目链接 普通平衡树 平衡树模版，splaysplaysplay实现。 #include <iostream> #include <cstdio> #include <cmath> #include <cstring> #include <set> #include <map> #include <queue> #include <stack> #include <vector> #include
04_map、set与平衡二叉搜索树、RBTree
m0_62624752的博客
05-11 190
(2条消息) 种树：二叉树、二叉搜索树、AVL树、红黑树、哈夫曼树、B树、树与森林_看，未来的博客-优快云博客 map和set都是关联式容器，其底层的实现都是RBTree（红黑树）， 1、map （1）map是一种字典的数据结构 （2）map底层是以RBTree作为容器 （3）所有元素在map中都是以键+值的形式存在 （4）不允许键重复，所有元素都是通过键直接排序的 （5）不允许键的修改，但是键对应的值可以修改 （6）可以支持下标操作，set不支持下标操作，map可以选择key作为下标，也
STL中的平衡二叉树（multiset set）
最爱晴天和自己的博客
08-04 2827
multiset set multimap map#include &lt;set&gt; //使用multiset和set需要此头文件  可在增加和删除数据的基础上查找数据。 multiset用法 multiset&lt;T&gt; st;   定义了一个multiset变量st，st里面可以存放T类型的数据，并且能自 动排序。开始st为空    size()  返回容器中元素的数...
SPOJ ORDERSET Order statistic set 简单平衡树 或 树状数组
弱智就要多努力
08-03 457
题目：http://www.spoj.com/problems/ORDERSET/en/题意：有下面四种操作： I x 往集合中插入x，若存在则不操作 D x 从集合中删除x，若不存在则不操作 K x 求集合中第x大的数，若x大于集合的大小输出invalid C x 统计集合中小于x的数的个数 思路：简单的平衡树题目，用treap很容易实现，另外学了一波pb_ds试着用了一下 treap：#inc
map+set+平衡二叉树
qq1024734546的博客
08-31 1025
1.关联式容器 STL中的部分容器，比如：vector、list、deque、forward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。 关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在 数据检索时比序列式容器效率更高。 特点 STL 关联容器的底层数据结构...
STL中的平衡二叉树（set)
羽的博客
01-04 690
STL中的平衡二叉树（set) 之前说了multiset 现在来说说set容器 set的用法 set 和 mulset 的区别在于容器里不能出现重复的元素 a 和b 重复 <=>“a 必须排在 b 前面” 和“b 必须排在a 前面” 都不成立。 set 插入元素可能不成功。（因为元素不能重复的原因，所以如果插入相同元素就会失败） set 用法示例： #include <cstdio> #include <iostream> #include <cstri
C++ string小记
xmu_cjs的博客
05-16 174
【代码】C++ string小计。
C++：STL
最新发布
2301_80311224的博客
05-20 140
STL：标准模板库，包含大量的模板类和模板函数，已被完全内置到支持C++的编译器中，不用再额外安装。接下来的帖子将分别进行说明。本帖将简介一下STL。
在C++中如何实现红黑树的数据结构，以及它与AVL树在平衡机制上的区别是什么？请结合代码示例进行说明。
11-07
在探索高级数据结构的过程中，红黑树是一个重要的主题，它作为自平衡二叉搜索树的实例，常被用于C++标准模板库（STL）中的map和set容器。红黑树与AVL树都是平衡二叉树，但它们在平衡性维护上采用了不同的策略。AVL树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值