秒懂C++之红黑树

已于 2024-08-23 21:11:16 修改
阅读量681 收藏 7
点赞数 19
分类专栏： c++ 数据结构 文章标签： 算法 c++ 数据结构
于 2024-08-23 21:08:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fax_player/article/details/141436781
版权

fe594ea5bf754ddbb223a54d8fb1e7bc.gif

目录

前言

一. 红黑树的概念

二. 红黑树的性质

三. 红黑树的插入

插入代码

四. 红黑树的验证

InOrder

IsBalance

五. 全部代码

前言

红黑树中涉及到了AVL树旋转的特点，如果对旋转不太了解可以去这篇文章：秒懂C++之AVL树-CSDN博客

一. 红黑树的概念

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

二. 红黑树的性质

  • 根节点必须是黑色
  • 每条路径下的黑色节点个数一致
  • 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
满足以上特性后红黑树就可以确保最长路径中的节点个数不超过最短路径的两倍了（实际上，就是维持平衡，不出现高度差为2的情况~）

三. 红黑树的插入

红黑树插入虽然情况不如AVL树多，但也有很多细节需要细细琢磨~

接下来我们开始根据各种情况进行具体分析~
第一种情况我们捋清逻辑其实很简单，我们找到插入的cur后只要u节点存在且为红色，那么让p/u节点变黑，g节点变红即可。然后以g节点作为cur不断从下层检查到上层，直到根节点~
既然u节点不存在需要按照AVL树的旋转思路解决问题，那就到了我们熟悉的主场了~
第二种情况当u不存在或者u存在且为黑时我们就利用旋转最后保持根节点为黑，左右孩子节点为红即可~ 
之所以不继续往上层遍历是因为当我们触发需要旋转来解决问题时，旋转最后的结果是不会影响到上层结构的，直接完成插入操作，不需要再检查其他节点了~

插入代码

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			//根节点为黑色
			_root->_col = 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->_col == RED)
		{
			//记录g节点
			Node* grandfather = parent->_parent;
			//记录u节点
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				//开始分类情况
				//情况一:u节点存在且为红
				if (uncle && uncle->_col == RED)
				{
					//p/g/u变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					//把g当作cur继续处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二:u节点不存在或u节点存在且为黑
				else
				{
					//情况二需要按照旋转情况进行分类
					//右旋情况，以g为旋转点
					if (cur == parent->_left)
					{
						//       g
						//    p     u
						// c 

						//右旋
						RotateR(grandfather);
						//p/g节点变色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//左右旋，p为旋转点后以g为旋转点
					else if (cur == parent->_right)
					{
						//       g
						//    p     u
						//		 c 

						//左旋
						RotateL(parent);
						//右旋
						RotateR(grandfather);
						//cur/g节点变色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					//旋转处理完毕，不用再向上处理，直接退出
					break;
				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				//开始分类情况
				//情况一:u节点存在且为红
				if (uncle && uncle->_col == RED)
				{
					//p/g/u变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					//把g当作cur继续处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二:u节点不存在或u节点存在且为黑
				else
				{
					//情况二需要按照旋转情况进行分类
					//左旋情况，以g为旋转点
					if (cur == parent->_right)
					{
						//       g
						//    u     p
						//			   c

						//左旋
						RotateL(grandfather);
						//p/g节点变色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//右左旋，p为旋转点后以g为旋转点
					else if (cur == parent->_left)
					{
						//       g
						//    u     p
						//		 c 

						//右旋
						RotateR(parent);
						//左旋
						RotateL(grandfather);
						//cur/g节点变色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					//旋转处理完毕，不用再向上处理，直接退出
					break;
				}
			

			}
					
		}
		//插入调整结束后我们统一让根节点变为黑色
		_root->_col = BLACK;
		//插入成功~
		return true;
	}

四. 红黑树的验证

InOrder

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

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

	void InOrder()
	{
		_InOrder(_root);
	}

IsBalance

bool Check(Node* cur)
	{
		if (cur == nullptr)
			return true;

		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

		return Check(cur->_left)
			&& Check(cur->_right);
	}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

		return Check(_root);
	}

不过这样还不够，我们还需要再验证一下各个路径下的黑色节点个数是否一致~
只有满足以下这三个核心才能说明该树为红黑树
  • 根节点必须是黑色
  • 每条路径下的黑色节点个数一致
  • 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
bool Check(Node* cur,int RedBlackNum,int BlackNum)
	{
		
		if (cur == nullptr)
		{
			if (RedBlackNum != BlackNum)
			{
				cout << "黑色节点不足" << endl;
				return false;
			}
			cout << BlackNum << endl;
			return true;
		}
			
		//检查是否存在连续的红色节点
		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}
		if (cur->_col == BLACK)
		{
			BlackNum++;
		}

		return Check(cur->_left,RedBlackNum, BlackNum)
			&& Check(cur->_right, RedBlackNum, BlackNum);
	}

	bool IsBalance()
	{	
		//检查根节点是否为黑色
		if (_root && _root->_col == RED)
			return false;
		//检查路径黑节点
		int RedBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				RedBlackNum++;
			}
			cur = cur->_left;
		}
		return Check(_root, RedBlackNum, 0);
	}

最后我们选择最左路径作为标准数量去对比其他路径是否与其一致~

五. 全部代码

#pragma once

enum Colour
{
	RED,
	BLACK
};

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

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

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	void RotateL(Node* parent)
	{
		//先完成左单旋基本规则
		//移动三个主要节点
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		subR->_left = parent;

		//再更新_parent
		if (subRL)
		{
			//为空就不用给了
			subRL->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		parent->_parent = subR;
		//若subR左旋后成为根节点
		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		//若subR左旋后不会成为根节点
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}

	void RotateR(Node* parent)
	{
		//先完成右单旋基本规则
		//移动三个主要节点
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		subL->_right = parent;

		//再更新_parent
		if (subLR)
		{
			//为空就不用给了
			subLR->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		parent->_parent = subL;
		//若subL右旋后成为根节点
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		//若subL右旋后不会成为根节点
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			//根节点为黑色
			_root->_col = 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->_col == RED)
		{
			//记录g节点
			Node* grandfather = parent->_parent;
			//记录u节点
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				//开始分类情况
				//情况一:u节点存在且为红
				if (uncle && uncle->_col == RED)
				{
					//p/g/u变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					//把g当作cur继续处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二:u节点不存在或u节点存在且为黑
				else
				{
					//情况二需要按照旋转情况进行分类
					//右旋情况，以g为旋转点
					if (cur == parent->_left)
					{
						//       g
						//    p     u
						// c 

						//右旋
						RotateR(grandfather);
						//p/g节点变色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//左右旋，p为旋转点后以g为旋转点
					else if (cur == parent->_right)
					{
						//       g
						//    p     u
						//		 c 

						//左旋
						RotateL(parent);
						//右旋
						RotateR(grandfather);
						//cur/g节点变色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					//旋转处理完毕，不用再向上处理，直接退出
					break;
				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				//开始分类情况
				//情况一:u节点存在且为红
				if (uncle && uncle->_col == RED)
				{
					//p/g/u变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					//把g当作cur继续处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二:u节点不存在或u节点存在且为黑
				else
				{
					//情况二需要按照旋转情况进行分类
					//左旋情况，以g为旋转点
					if (cur == parent->_right)
					{
						//       g
						//    u     p
						//			   c

						//左旋
						RotateL(grandfather);
						//p/g节点变色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//右左旋，p为旋转点后以g为旋转点
					else if (cur == parent->_left)
					{
						//       g
						//    u     p
						//		 c 

						//右旋
						RotateR(parent);
						//左旋
						RotateL(grandfather);
						//cur/g节点变色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					//旋转处理完毕，不用再向上处理，直接退出
					break;
				}
			

			}
					
		}
		//插入调整结束后我们统一让根节点变为黑色
		_root->_col = BLACK;
		//插入成功~
		return true;
	}

	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 RedBlackNum,int BlackNum)
	{
		
		if (cur == nullptr)
		{
			if (RedBlackNum != BlackNum)
			{
				cout << "黑色节点不足" << endl;
				return false;
			}
			cout << BlackNum << endl;
			return true;
		}
			
		//检查是否存在连续的红色节点
		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}
		if (cur->_col == BLACK)
		{
			BlackNum++;
		}

		return Check(cur->_left,RedBlackNum, BlackNum)
			&& Check(cur->_right, RedBlackNum, BlackNum);
	}

	bool IsBalance()
	{	
		//检查根节点是否为黑色
		if (_root && _root->_col == RED)
			return false;
		//检查路径黑节点
		int RedBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				RedBlackNum++;
			}
			cur = cur->_left;
		}
		return Check(_root, RedBlackNum, 0);
	}

private:
	Node* _root = nullptr;
};

void test1()
{
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}

	t.InOrder();
	cout << t.IsBalance() << endl;
}

玛丽亚后
关注
  • 19
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【文章汇总】嵌入式Linux公众号
嵌入式Linux
01-08 1万+
据悉，深圳某工程师沦为C语言笔试枪手 修改cmdline 把内存改成512MB 上拉电阻的作用 剖析C语言是如何画出这样的三角形的 c语言画谢宾斯基三角形 Linux字符设备驱动实例 哦，这是桶排序 回答一个微信好友的创业问题 Linux-C编程 / 多线程 / 如何终止某个线程？ 想要学好C++有哪些技巧？ 单片机外围模块漫谈之二，如何提高ADC转换精度 多重 for 循环，如何提高效率？ Linus 在圣诞节想提前放假做了这些解释，哈哈哈 一步步分析-C语言如何面向对象编程 测试内存对齐对运行速度的影响
腾讯IEG后台开发(已拿到offer)
热门推荐
qq_35170267的博客
03-11 2万+
今天是3月11日，鹅肠技术一面，电话面 2019年3月11日 星期一 本人浙江大学软件学院研一研究生。 当时投递岗位的时候没有看清要求，写着后台开发岗，招C/C++/Java，果然越靠前越重要。。本来想投的是Java岗，奈何鹅肠后台C++偏多。结果面试的时候面的全是C++和Linux，Java一点没问。全程大概25分钟，总结如下。 面试内容和我的回答 先自我介绍一下吧 好，我叫xx, 目前...
【C++】红黑树插入删除
fight_p的博客
12-14 1345
这是一篇关于红黑树插入删除为主要内容的文章，本文详细讲述了红黑树的插入情形以及如何解决，代码如何实现，当然最重要的就是红黑树的删除，虽然红黑树删除不简单，但是删除的无非就是叶子节点，一个孩子的节点，两个孩子的节点，被删节点是红色还是黑色。其中最重要的就是删除的黑色叶子节点这有些麻烦，其他的都很简单！本文把每个情况都详细罗列出来。其实看完之后红黑树的删除真的没有那么难！！！
秒懂C++之set、map的封装
fax_player的博客
08-24 996
这就有点奇怪了，红黑树设置kv模型第一个参数为pair就行了，为什么这里有两个参数？前我们还面临一个问题，key是不支持修改的~而我们现在只能通过降低传参权限去限制~我们修改获取_data数据的方式就行了~
【C++】AVL树和红黑树的插入
The porters of knowledge
03-29 801
AVL树的旋转调平衡：单旋时三叉链结构的诸多细节，双旋时恶心的平衡因子调节。红黑树的旋转+变色：关键在于uncle的颜色，第一次新增红色结点只可能出现第一种情况，没有可能出现第2或3种情况，2或3都是1之后延申。
Learning C++ No.20 【红黑树实战】
狂小伍的博客
05-13 1063
一文带你搞定红黑树
十年C++企业级架构师分享：C++的核心知识点有哪些？
03-10 1984
C++是一门被广泛使用的系统级编程语言，更是高性能后端标准开发语言；C++虽功能强大，灵活巧妙，但却属于易学难精的专家型语言，不仅新手难以驾驭，就是老司机也容易掉进各种陷阱。 这是小编准备的C++学习资料，加小编学习群：825414254，加群即可获取哦！ 本文结合作者的工作经验和学习心得，对C++语言的一些高级特性，做了简单介绍；对一些常见的误解，做了解释澄清；对比较容易犯错的地方，做了归纳总...
C++高性能网络服务保姆级教程 day02 真正的高并发还得看IO多路复用
weixin_sjk6070的博客
04-27 1357
上节从一个基础的socket服务说起我们实现了一个基本的socket服务器，并留了个思考题 先启动server，然后启动一个client，不输入数据，这个时候在另外一个终端上再启动一个client，并在第二个client终端中输入数据，会发生什么呢？ 实际操作后，我们会发现，在第二个client输入后，服务端并没有响应，直到第一个client也输入数据完成交互后，第二个client才会有数据返回。 这是由于服务端accept获取到第一个client的套接字后，由于第一个client未输入数据，所以服务端进程
微信开源C++Libco介绍与应用（二）
didi_cloud的博客
11-28 203
上文我们介绍了Libco的初步介绍与协程，接下来让我们继续往下看~Libco 协程的生命周期创建协程（Creating coroutines）前文已提到，libco 中创建协程是 co_create() 函数。函数声明如下：int co_create(stCoRoutine_t** co, const stCoRoutineAttr_t* attr, void* (*routine)(void*)...
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 951
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
算法025：前缀和
m0_62319039的博客
08-22 297
算法025：前缀和
数据结构与算法——Java实现 2.衡量算法好坏的标准
最新发布
m0_73983707的博客
08-27 246
为了对 f(n)进行化简，应当抓住主要矛盾，找到一个变化趋势与之相近的表示法。与时间复杂度类似，一般也使用大O表示法来衡量：一个算法执行随数据规模增大，而。假设算法要处理的数据规模是n，代码总的执行行数用函数 f(n)来表示。③ 不同底数的对数，渐进上界可以用一个对数函数 log n 表示。时间复杂度是用来衡量:一个算法的执行，随数据规模增大，而。② 多项式中数量规模更小(低次项)的表达式。① 表达式中相乘的常量，可以省略。④ 类似的，对数的常数次幂可省略。已知 f(n) ，求 g(n)
1087：级数求和
如果没有特别说明，c++都是基于GCC-4.9.2运行的
08-22 351
【代码】：1087：级数求和
算法笔试-编程练习-01-B-23
志远的博客
08-23 914
小红组内有 n 个人，大家合作完成了一个初版方案，初始时大家的愤怒值都是 0。 但是领导对方案并不满意，共需要修改 m 次方案，每次修改会先让第 l 到 r 个人的愤怒值加 1，然后再修改方案；
代码随想录算法训练营第二十二天| 回溯算法理论基础 77. 组合 216.组合总和III 17.电话号码的字母组合
Mwicogito的博客
08-23 1145
回溯法章节开始，逐渐开始正式复习算法设计课的知识。文章图片来源：代码随想录 (https://programmercarl.com/)
【算法】动态规划
小匠码农
08-26 986
动态规划、最长公共子序列
树状数组算法
2302_81590667的博客
08-23 931
lowbit这个函数的功能就是求某一个数的二进制表示中最低的一位1，举个例子，x = 6，它的二进制为110，那么lowbit(x)就返回2，因为最后一位1表示2。2.树状数组的作用被线段树完全涵盖, 凡是可以使用树状数组解决的问题, 使用线段树一定可以解决, 但是线段树能够解决的问题树状数组未必能够解决.看下图我们会发现，数组的下标其实是有规律的，就比如下标为1，3，5，7的二进制最后一位1都是2。然后她再给你一个下标x，和一个数y让你执行操做1，就可以执行这样的操作。就比如他给你一个数组个数为n。
迭代器的失效问题
qq_58158950的博客
08-24 342
同理再看这段代码，在所有偶数元素位置前插入一个该偶遇元素减去1的元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值