秒懂C++之红黑树

news2024/11/16 1:46:52

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;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2068193.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

ZNS SSD是不是持久缓存的理想选择？

ZNS SSD是不是持久缓存的理想选择？

随着数据量的增加和技术的进步&#xff0c;对于高效、可靠的存储解决方案的需求日益增长。传统的基于块的SSD虽然具有成本效益和持久性的优点&#xff0c;但在处理写密集型和更新密集型工作负载时存在局限性。 NAND闪存的特点是数据只能按页&#xff08;例如4KiB&#xff09;写…
阅读更多...
【国赛】【美赛】【五一杯】【电工杯】【华数杯】【亚太杯】······各赛事历年优秀论文+真题分享

【国赛】【美赛】【五一杯】【电工杯】【华数杯】【亚太杯】······各赛事历年优秀论文+真题分享

今天继续给大家分享十分重磅的资料哦&#xff0c;数学建模各大竞赛的资料汇总&#xff0c;可能很多小伙伴平时进行某个比赛的资料搜索的时候会发现&#xff0c;我们想要的这个比赛的资料有时候非常难搜索到&#xff0c;搜索23年&#xff0c;显示21年的&#xff0c;搜索小美赛&a…
阅读更多...
Prometheus 监控指标采集

Prometheus 监控指标采集

原文链接&#xff1a;https://www.hezebin.com/article/66b3b1fb4379b36dec11a1a1 前言 在现代分布式系统和云原生环境中&#xff0c;为了确保复杂的分布式系统和服务的高可用性、可靠性和性能&#xff0c;通常采用实时可视化监控和分析&#xff0c;实现故障快速响应、资源优…
阅读更多...
单片机驱动彩屏最简方案：单片机_RA8889最小开发板驱动控制TFT彩屏介绍（二）硬件电路设计

单片机驱动彩屏最简方案：单片机_RA8889最小开发板驱动控制TFT彩屏介绍（二）硬件电路设计

本文介绍使用单片机RA8889来驱动和控制彩屏的最小方案。文章从RA8889的架构功能、硬件电路设计及软件设计三个方面来说明。 小编已发布多篇文章介绍了单片机RA8889来驱动控制彩屏&#xff0c;但是仍有不少单片机玩家可能对驱动彩屏还不算熟悉&#xff0c;在此加推一个短篇介绍…
阅读更多...
机器学习-随机森林（全网最详解）

机器学习-随机森林（全网最详解）

文章目录 一、简介1.定义2.基本原理3.优缺点4.应用场景 二、代码运用1.数据预处理2.模型训练3.模型评估4.绘制特征排名 三、总结 一、简介 1.定义 随机森林&#xff08;Random Forest&#xff09;是一种集成学习方法&#xff0c;它通过构建多个决策树并将它们的预测结果进行汇…
阅读更多...
公司电脑被监控有什么表现？电脑监控VS员工隐私，员工合理摸鱼需知！职场小贴士为您解答！

公司电脑被监控有什么表现？电脑监控VS员工隐私，员工合理摸鱼需知！职场小贴士为您解答！

公司电脑被监控有什么表现&#xff1f; 数字化办公日益普及&#xff0c;许多企业为了保障信息安全、提升工作效率&#xff0c;会选择在公司电脑上安装监控软件。这一举措在提升企业管理效能的同时&#xff0c;也引发了关于员工隐私与合理工作界限的讨论。本文将为您解析公司电…
阅读更多...
k8s教程

k8s教程

1. k8s框架 - kubernetes的架构- Control Plane: 控制K8S集群的组件。- Api Server: 集群的访问入口。- etcd: 存储集群的数据。一般情况下&#xff0c;只有API-SERVER会访问.- Control Manager: 维护集群的状态。- Scheduler: 负责Pod的调度功能。- Wor…
阅读更多...
防止拷贝电脑资料？【三种数据拷贝的详细方法分享！】

防止拷贝电脑资料？【三种数据拷贝的详细方法分享！】

防止电脑资料被拷贝通常是指采取措施来保护敏感或专有信息不被未经授权的用户复制或传播。 这里我理解您可能想要了解的是如何防止数据被拷贝的方法&#xff0c;而不是进行数据拷贝的方法。 下面是一些常见的防止数据拷贝的策略和技术&#xff1a; 1. 物理安全控制 锁屏或密…
阅读更多...
一篇讲完自动化基础-Python【万字详细讲解】

一篇讲完自动化基础-Python【万字详细讲解】

​ ​ 您好&#xff0c;我是程序员小羊&#xff01; 前言 这篇文章主要学习Python的语法&#xff0c;为后续的自动化打基础 Python requests 接口自动化 Python selenium web 自动化 Python appium移动端自动化(手机 app) 这篇文章分六个阶段百分比进行划分&#xff0c;到时…
阅读更多...
Elasticsearch：使用 semantic_text 进行语义搜索

Elasticsearch：使用 semantic_text 进行语义搜索

警告&#xff1a;截止 8.15 版本&#xff0c;此功能处于测试阶段&#xff0c;可能会发生变化。设计和代码不如官方 GA 功能成熟&#xff0c;并且按原样提供&#xff0c;不提供任何保证。测试版功能不受官方 GA 功能的支持 SLA 约束。 本教程向你展示如何使用 semantic text 功能…
阅读更多...
硬件检测工具箱 | 入梦工具箱 v8.8

硬件检测工具箱 | 入梦工具箱 v8.8

入梦工具箱&#xff08;RM Toolbox&#xff09;是一款专为硬件检测、评分和测试设计的免费开源软件。它以其小巧的体积和简洁的界面&#xff0c;迅速成为DIY玩家和硬件爱好者的首选工具。 功能特点 集成常用硬件检测工具&#xff1a;包括CPUZ、GPUZ、AIDA64等&#xff0c;全面…
阅读更多...
3种将4K视频转换成1080P格式的无损方法

3种将4K视频转换成1080P格式的无损方法

用户总是倾向于将 4k 视频转换为 1080p&#xff0c;以便缩小它们并在兼容设备上观看。这种 4k 到 1080p 的转换被称为降频或降级&#xff0c;因为视频分辨率降低了。如果你想知道如何在不损失质量的情况下将 4k 缩小到 1080p&#xff0c;那么这是你找到答案的正确地方。阅读以下…
阅读更多...
在idea中的git选择某一次记录拉出一个新分支

在idea中的git选择某一次记录拉出一个新分支

一 创建新分支 1.1 操作步骤 需求&#xff1a;需要在图中标红的历史记录&#xff0c;从此记录拉出一个分支 1.右键【new branch】 2.起一个新的名字&#xff1a; 3.新分支代码
阅读更多...
HTTP协议相关知识

HTTP协议相关知识

1 HTTP协议的解读 1.1 HTTP和HTTPS区别 HTTP协议&#xff1a;超文本传输协议是互联网上应用最为广泛的一种网络协议。所有的HTML文件都必须遵守这个标准。设计HTTP最初的目的是为了提供一种发布和接收HTML页面的方法 HTTPS协议&#xff1a;HTTP协议的安全版&#xff0c;在HT…
阅读更多...
快9月了才开始强化，刷张宇1000还是李林880？

快9月了才开始强化，刷张宇1000还是李林880？

如果你现在才开始强化&#xff0c;并且在张宇1000和李林880中间纠结&#xff0c;可以花5分钟看看这篇文章&#xff01; 张宇1000题&#xff0c;今年进行了改版&#xff0c;去掉了一些「偏难怪」的题目&#xff0c;这类题目&#xff0c;对于大家的友好度明显上升。但是难度和综合…
阅读更多...
springboot admin监控

springboot admin监控

服务端搭建 maven的依赖&#xff0c;包括服务端和客户端&#xff0c;以及注册到nacos上面 <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0" xmlns:xsi"http://www.w3.org/2001/XML…
阅读更多...
游戏服务器租用多少钱一年？

游戏服务器租用多少钱一年？

游戏服务器租用多少钱一年&#xff1f;游戏服务器租用的价格范围非常广泛&#xff0c;从几百元到数万元不等。对于入门级或小型游戏服务器&#xff0c;一年的租用费用可能在几百到几千元之间&#xff1b;而对于高级或大型游戏服务器&#xff0c;一年的费用可能会超过数万元。 …
阅读更多...
宽压宽频（35V/45V/65V）50KHZ-3MHZ双向同步降压升压LED驱动器QFP32封装

宽压宽频（35V/45V/65V）50KHZ-3MHZ双向同步降压升压LED驱动器QFP32封装

概述&#xff1a; PC9248 是一款双向降压-升压控制器&#xff0c;适用于驱动高效功率转换器中的硅&#xff08; Si&#xff09; MOSFET 或氮化镓&#xff08;GaN&#xff09;功率晶体管。它支持高达 45V 的宽输入和输出范围&#xff0c;可在降压、降压-升压和升压模式之间无缝…
阅读更多...
XSS-复现dom破坏案例和靶场

XSS-复现dom破坏案例和靶场

目录 xss注入原理&#xff1a; xss是什么&#xff1f; xss原理&#xff1a; DOM&#xff1a; 闯关&#xff1a; 第一关&#xff1a;Ma Spaghet! 源码&#xff1a; 要求&#xff1a; 分析&#xff1a; 第二关&#xff1a; Jefff 源码&#xff1a; 要求&#xff1a; …
阅读更多...
QT读取数据库中文显示乱码

QT读取数据库中文显示乱码

QT读取数据库中文显示乱码 使用ODBC连接数据库时&#xff0c;选择Character Set为gbk格式
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023