手撕红黑树（map和set底层结构）（2）

最新推荐文章于 2024-09-30 09:51:27 发布
最新推荐文章于 2024-09-30 09:51:27 发布
阅读量633 收藏 14
点赞数 21
分类专栏： C++进阶 文章标签： linux stm32 单片机 java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73802195/article/details/138005901
版权

@[TOC]红黑树

一 红黑树概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

简单来说红黑树通过了对颜色的控制进而对树的长度做出了限制，不再需要平衡因子。
红黑树性质

  1. 每个节点不是红色就是黑色
  2. 根节点为黑色
  3. 如果一个节点是红色，那么他的孩子节点就是黑色。没有连续的红色节点
  4. 对于每个节点，他的所以路径上的黑色节点的数量是相同的。
  5. 每个叶子节点都是黑色的（注意：这里的叶子节点指的是空节点）

红黑树通过这些性质保证了他的高度是合法的。
在这里插入图片描述
红黑树保证的是：最长路径不超过最短路径的两倍

二 红黑树的实现

2.1 红黑树的结构

enum Color
{
	Red,
	Black,
};


template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Color _color;
	pair<K, V> _kv;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _color(Red)
		, _kv(kv)
	{}
};
template<class K,class V>
class RBtree
{
	typedef RBTreeNode<K, V> Node;
	private:
	Node* _node=nullptr;
}

2.2 红黑树的插入

在这里插入图片描述
我们要注意：我们在插入新节点的时候，默认插入元素的颜色为红色，（黑色节点不好控制，因为要保证全部的路径的黑色节点数量是相同的，插入了一个黑色节点，就不能保证这一原则了）
然后插入元素对整棵树的影响我们就要从局部开始看，

  1. 如果插入元素的父亲为黑色那就不用在变化了；
  2. 插入元素的父亲为红色，此时就出翔了连续的红色节点，我们就要对这颗树进行处理；

我们对第二种情况分类讨论（用上述的图片为例）

第一种：cur为红，p为红，g为黑，u存在且为红

把p和u变为黑色，再把g变成红色；
到这里就要继续分类讨论：

  1. g为根节点，那就把g再变成黑色。
  2. 如果不是根节点，就把g=c，向上继续处理
    注意（p/u是g的左还是右都不影响，同样cur是p的左还是右也不影响）

第二种: cur为红，p为红，g为黑，u不存在/u存在且为黑
（i）u不存在在这里插入图片描述
这里cur一定是新插入的节点，如果cur不是新插入的节点，cur和p一定有一个是黑色的。
（ii）u存在且为黑色在这里插入图片描述
这里的cur就不是新插入的节点，u是黑色那么，每个路径下黑色节点数量一定相同，所以cur原本一定是黑色的，是因为新插入的原因被变成了红色。
以上这两个情况本质上是一种。
这里就要用到旋转，旋转和前面AVL树的旋转一模一样

p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，
p为g的右孩子，cur为p的右孩子，则进行左单旋转
旋转完：p、g变色–p变黑，g变红。

参考下面的图，进一步理解
在这里插入图片描述
在这里插入图片描述
第三种 cur为红，p为红，g为黑，u不存在/u存在且为黑，但这里的左右位置不同

(i) p为g的左，cur为p的右
在这里插入图片描述
在这里插入图片描述
可以看到这里就变回了情况二，根据上面的我们再进行右单旋即可。
在这里插入图片描述
(i) p为g的右，cur为p的左

这个就是先右旋+左旋即可。这个图留个大家去完成。

2.3代码

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_color = Black;
			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 && parent->_color == Red)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//情况一：存在且为红
				if (uncle && uncle->_color == Red)
				{
					//变色
					parent->_color = Black;
					uncle->_color = Black;
					grandfather->_color = Red;
					//向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二：不存在or存在且为黑
				else
				{
					//旋转+变色
					//    g
					//  p    u
					//c
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_color = Black;
						grandfather->_color = Red;
					}
					else
					{
						//情况三
						//    g
						//  p    u
						//     c  
						RotateL(parent);
						RotateR(grandfather);
						cur->_color = Black;
						grandfather->_color = Red;
					}
					break;
				}
			}
			else//p是g的右孩子
			{
				Node* uncle = grandfather->_left;
				//情况一：存在且为红
				if (uncle && uncle->_color == Red)
				{
					//变色
					parent->_color = Black;
					uncle->_color = Black;
					grandfather->_color = Red;
					//向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二：不存在or存在且为黑
				else
				{
					//旋转+变色
					//    g
					//  u   p
 					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_color = Black;
						grandfather->_color = Red;
					}
					else
					{
						//情况三
						//    g
						//  u   p
						//     c
						RotateR(parent);
						RotateL(grandfather);
						cur->_color = Black;
						grandfather->_color = Red;
					}
					break;
				}
			}
		}
		_root->_color = Black;

		return true;
	}

三 检查函数

	bool Check(Node* cur, int BlackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			if (BlackNum != refBlackNum)
			{
				cout << "黑色节点的数量不匹配" << endl;
				return false;
			}
			else
				return true;
		}
		if (cur->_color == Red && cur->_parent->_color == Red)
		{
			cout << "出现了连续的红色节点" << endl;
			return false;
		}
		if (cur->_color == Black)
			++BlackNum;
		return Check(cur->_left, BlackNum, refBlackNum) &&
			Check(cur->_right, BlackNum, refBlackNum);

	}
	bool IsBalance()
	{
		if (_root == nullptr || _root->_color == Red)
			return false;
		//给一个基准值，和其他的黑色节点去比较
		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == Black)
				++refBlackNum;
			cur = cur->_left;
		}
		return Check(_root, 0, refBlackNum);
	}

四 总结

总的来说红黑树的实现和AVL树非常像，他们就是兄弟，红黑树就是把考虑的因素从平衡因子转变成了颜色。

五 完整代码

#pragma once
#include<assert.h>
#include<vector>
enum Color
{
	Red,
	Black,
};


template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Color _color;
	pair<K, V> _kv;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _color(Red)
		, _kv(kv)
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_color = Black;
			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 && parent->_color == Red)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//情况一：存在且为红
				if (uncle && uncle->_color == Red)
				{
					//变色
					parent->_color = Black;
					uncle->_color = Black;
					grandfather->_color = Red;
					//向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二：不存在or存在且为黑
				else
				{
					//旋转+变色
					//    g
					//  p    u
					//c
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_color = Black;
						grandfather->_color = Red;
					}
					else
					{
						//情况三
						//    g
						//  p    u
						//     c  
						RotateL(parent);
						RotateR(grandfather);
						cur->_color = Black;
						grandfather->_color = Red;
					}
					break;
				}
			}
			else//p是g的右孩子
			{
				Node* uncle = grandfather->_left;
				//情况一：存在且为红
				if (uncle && uncle->_color == Red)
				{
					//变色
					parent->_color = Black;
					uncle->_color = Black;
					grandfather->_color = Red;
					//向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二：不存在or存在且为黑
				else
				{
					//旋转+变色
					//    g
					//  u   p
 					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_color = Black;
						grandfather->_color = Red;
					}
					else
					{
						//情况三
						//    g
						//  u   p
						//     c
						RotateR(parent);
						RotateL(grandfather);
						cur->_color = Black;
						grandfather->_color = Red;
					}
					break;
				}
			}
		}
		_root->_color = Black;

		return true;
	}

	void RotateL(Node* parent)
	{
		//++rotateSize;

		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}

	void RotateR(Node* parent)
	{
		//++rotateSize;

		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << endl;
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
	}

	///
	//检查函数
	bool Check(Node* cur, int BlackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			if (BlackNum != refBlackNum)
			{
				cout << "黑色节点的数量不匹配" << endl;
				return false;
			}
			else
				return true;
		}
		if (cur->_color == Red && cur->_parent->_color == Red)
		{
			cout << "出现了连续的红色节点" << endl;
			return false;
		}
		if (cur->_color == Black)
			++BlackNum;
		return Check(cur->_left, BlackNum, refBlackNum) &&
			Check(cur->_right, BlackNum, refBlackNum);

	}
	bool IsBalance()
	{
		if (_root == nullptr || _root->_color == Red)
			return false;
		//给一个基准值，和其他的黑色节点去比较
		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == Black)
				++refBlackNum;
			cur = cur->_left;
		}
		return Check(_root, 0, refBlackNum);
	}
private:
	Node* _root = nullptr;
};


void TestRBTree1()
{
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 14,16};
	RBTree<int, int> t;
	for (auto e : a)
	{
		if (e == 16)
		{
			int x = 0;
		}
		t.Insert(make_pair(e, e));

		// 1、先看是插入谁导致出现的问题
		// 2、打条件断点，画出插入前的树
		// 3、单步跟踪，对比图一一分析细节原因
		cout << e << "->" << t.IsBalance() << endl;
	}

	t.InOrder();
	cout << t.IsBalance() << endl;
}
tpoog
关注
专栏目录
【手撕STL】map和set
AI_ELF的博客
07-09 804
这里写目录标题setset的使用举例map三级目录 set set文档介绍 set是按照一定次序存储元素的容器 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。 set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭
【C++】用手搓的红黑树手搓set和map
学了就忘是正常现象
03-19 2794
C++map和set的底层原理。
【C++、数据结构】封装map和set（用红黑树实现）
上上谦. 的博客
02-05 937
在这之前我们学习了红黑树的模拟实现，学习了如何使用map和set，同时我们也了解到，map和set底层都是用红黑树来实现的，本文我们就要自己动手封装一下map和set这两大容器，用我们之前学的红黑树来实现一下……🙋 🙋 🙋 🙋 🙋前情回顾：手撕红黑树👉传送门前情回顾：map和set👉传送门//上层维度的一个泛型 template < class T > struct RBTreeNode {T _data;//数据 Colour _col;} };
手撕红黑树（kv模型模拟）
2201_75373858的博客
04-24 2307
本篇博客介绍红黑树结构,通过模拟红黑树的插入，来深入理解红黑树的结构以及调整规则，红黑树原理剖析，看这一篇就够了（包会）
C++手撕红黑树
ye_yumo的博客
04-08 1293
我们定义颜色时，使用枚举类型，可以方便且明了的看到颜色除此之外我们默认插入节点是红色的，因为一旦插入节点是黑色，就会违反第四条规则，如果要满足的话，就要走到每一条路径上插入对应的黑色节点，代价巨大当插入节点是红色时，有可能会违反第三条规则，但是我们可以通过变色，旋转等操作在局部进行改变，这样就能使之仍然满足条件。
【C++/STL】：红黑树的应用 --- 封装map和set
2301_77900444的博客
07-27 1678
map 和 set 的底层本质上还是复用通过对红黑树的改造，再分别套上一层 map 和 set 的 “壳子”，以达到 “一树二用” 的目的。在改造红黑树的过程中，我大概归纳了以下几个需要重点解决的问题：(1) 对红黑树节点的改造。关联式容器中存储的是的键值对，K为key的类型，如果是 set 则是 K，如果是map，则为pair。如何用一个节点结构控制两种类型，使用类模板参数T。(2) 在插入操作时，如何完成数据的比较。
【手撕STL】红黑树
AI_ELF的博客
07-07 870
红黑树一级目录二级目录三级目录 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的 注： AVL树：左右高度差不超过1，严格平衡 红黑树：最长路径不超过最短路径的2倍，近似平衡 红黑树的性质： 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 （树里面没有连续的红节点） 对于每个结点，从该结点
手撕红黑树
weixin_47843332的博客
10-22 141
首先声明，这是个人看看完 该红黑树教程。掺杂了个人理解。不是面面俱到，所以如果有小伙伴点击进来想学红黑树，我建议先把视频看一遍，然后在看着我的笔记，默写出红黑树。 红黑树的本质 ① 所有节点非红即黑 ② 根节点必须为黑色 ③ 所有的叶子节点都是黑色（NIL节点。多数情况下隐藏） ④ 没有两两连续的红色节点，也就是说红色节点的孩子节点必须是黑色 ⑤ 任意一个节点，到叶子节点所经过的黑色节点数目一样多（简称 “黑高”一致） 以上的性质完成对应的2-3-4树（4阶的B - tree）如果不懂 还是建议把视频
红黑树同时封装实现 map 和 set——红黑树の华丽二重奏
qq_61500888的博客
09-08 2188
带你一命通关 map ，set 底层原理 咋舌细品红黑树魅力，二十分钟手撕数据结构
树：红黑树，线段树。手撕源码。从入门到入坑 更新版
double_app_le的博客
04-07 342
首先，我们要将线段树和二叉树进行比较: 后者每个结点代表一个权值，前者为一段范围。 范围可以涉及到，一段范围内的最大值，权值和等等 为什么要用到线段树：（有点像二分查找法） 原本用普通查找方法要 O(n); 用线段树可缩小为O（根号2）； 例题： 试题 算法训练 操作格子 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于
【手撕STL】unordered_set、unordered_map(用哈希表封装)
AI_ELF的博客
07-11 1761
unordered_map在线文档说明 注意：unordered_set在线文档说明注：在功能上和map、set是一样的区别在于，这两个容器遍历出来不是有序的，他们是单向迭代器 运行结果： 注：unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。总结：注： 当存储的数据没有特定说明需要排序时，一定要用unordered系列的关联式容器；当需要存储的序列为有序时，应该选用ordered系列的关联式容器对于两个数据元素的关键字 ki和kj (i != j)，有ki !=kj ，但有：
还没吃透面试必问的红黑树？图文并茂的让你彻底理解红黑树
m0_73257876的博客
09-06 224
时间 2022-09-06 12:12:32原文主题点击左上方蓝色“”，选择“”第一时间看干货文章☞ 【 专辑 】☞ 【干货】☞ 【干货】正在上传…重新上传取消11. 红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。
手撕Java和Go的Map
qq_41354702的博客
08-29 607
文章目录Java的MapHashMap底层用到数组+链表？工作原理？get()方法的实现过程？重写equals方法需同时重写hashCode方法？jdk1.8链表基础上超过8换成红黑树进一步加速查找速度扩容操作？通过resize()方法HASH方法？链地址法为什么数组长度要保证为2的幂次方呢？Object作为K应该怎么办呢？初始化长度？与HashTable关键不同点？Go的Mapmapmap的结构？key的定位写入的流程扩容 Java会比Go详细点，因为我先学的Java，最近学的Go。有一点比较明显的，Go
linux 网络序
最新发布
CodeHouse的博客
09-30 282
在将ip字符串转网络序存储时。根据整形二进制显示判断。
【Linux实践】实验四：Shell实用功能及文件权限
Fulling的博客
09-25 776
实验内容 1、使用命令“cat /etc/named.conf”设置为别名named，然后再取消别名。 2、使用echo命令和输出重定向创建文本文件/root/nn，内容是hello，然后再使用追加重定向输入内容为word。 3、使用管道方式分页显示/etc/passwd的内容。 4、分别用文字设定法和数字设定法，对/root/ab文件设置权限，所有者为读取、写入和执行权限，同组用户为读取和写入权限，其他用户没有任何权限。 5、将文件/root/ab所有者更改为用户zhangsan。 6、将目录/root/
在 Kali Linux 中安装 Impacket
weixin_44023460的博客
09-30 155
在安装 Impacket 之前，你需要确保安装了 Python 和一些必要的依赖。通常，Kali 已经预装了 Python。步骤 3：克隆 Impacket 仓库。步骤 4：进入 Impacket 目录。如果你看到帮助信息，说明安装成功。步骤 5：安装 Impacket。
Linux 安装redis主从模式+哨兵模式3台节点
一千个读者就有一千个哈姆雷特
09-27 398
Linux 安装redis主从模式+哨兵模式3台节点
linux 源代码编译
Lxn2zh的博客
09-27 1339
有时候会在linux上下载源码包，然后进行编译成可执行的文件，这个过程需要经过configure、make、make install、make clean四个步骤。configure 为这个程序在当前的操作系统环境下选择合适的编译器和环境参数来编译该代码。make install 将已编译好的可执行文件安装到操作系统指定或默认的安装目录下。make 对程序代码进行编译操作，会将源码编译成可执行的目标文件。make clean 删除编译时临时产生的目录或文件。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

tpoog

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

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

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

打赏作者

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

抵扣说明：

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

余额充值