C++-第十三章：红黑树

news2025/2/28 13:27:41

目录

第一节：红黑树的特征

第二节：实现思路

        2-1.插入

                2-1-1.unc为红

                2-1-2.cur为par的左子树，且par为gra的左子树(cur在最左边)

                        2-1-2-1.unc不存在

                        2-1-2-2.unc为黑

                2-1-3.cur为par的右子树，且par为gra的右子树(cur在最右侧)

                        2-1-3-1.unc不存在

                        2-1-3-2.unc为黑

                2-1-4.cur为par的左子树，且par为gra的右子树（cur在左内侧）

                        2-1-4-1.unc无关

                2-1-5.cur为par的右子树，且par为gra的左子树(cur在右内侧)

                        2-1-5-1.unc无关

                2-1-6.par为黑

        总结：

第三节：代码实现

        2-1.Node类

        2-2.RBTree类

 Gitee：红黑树 · 转调/C++ - 码云 - 开源中国

第四节：测试

下期预告：

第一节：红黑树的特征

        红黑树并没有AVL树那种严格的平衡因子限制，它只保证最长路径的长度不会超过最短路径的两倍。

        红黑树的特征如下：

        （1）节点分为两种"红"与"黑"

        （2）根节点是"黑"

        （3）"红"节点的孩子都是"黑"节点——不存在连续的"红"节点

        （4）对于每个节点，从该节点开始，到叶子节点结束，的所有简单路径均包含相同数量的"黑"节点

        上述的"红"与"黑"并不是指颜色，只是区分两种节点的方法。

第二节：实现思路

        2-1.插入

        插入时优先将新增节点设置为红色，否则因为规则(4)的制约，黑节点会影响多条路径。

        假如新插入的节点为cur，它的父亲为par，爷爷为gra，父亲的兄弟为unc，那么一共有多种情况。

        当par为红时，因为规则(2)，一定有一个黑色gra，只有一个unc是未知的

        所以先讨论par为红时的情况：

                2-1-1.unc为红

                                

        这种情况就违反了规则(3)，所以要进行改变：

        将par、unc变为黑色，gra变为红色。

                ​​​​​​​        ​​​​​​​        

        此时这个子树已经符合红黑树的规则了，但是对于gra之上的节点来说，变红的gra等价于插入了一个红色的cur，所以又要将gra作为cur，继续向上调整，直到根或者par为"黑"。这是一种递归的思想。

        其次，如果gra就是root，那么根据规则(2)还需要把gra变为黑色。

                2-1-2.cur为par的左子树，且par为gra的左子树(cur在最左边)

                        2-1-2-1.unc不存在

                                        

        此时要在gra和par之间进行右单旋，旋转方式和AVL树的右单旋一致。

        然后将gra变红，par变黑。

        因为par已经变成黑色了，所以不再向上更新。

                        2-1-2-2.unc为黑

                                

        此时也执行与2-1-2-1相同的操作，即在par和gra之间进行右单旋；

        然后将gra变红，par变黑。

        它也不用再向上更新了。

        总结： cur在最左边时，gra和par右单旋+变色。

                2-1-3.cur为par的右子树，且par为gra的右子树(cur在最右侧)

                        2-1-3-1.unc不存在
                        2-1-3-2.unc为黑

        这两种情况和2-1-2的位置情况相反，cur从最左变到了最右，处理方法也类似，只是把右单旋操作变成了左单旋操作。

        总结：cur在最右侧时，gra和par左单旋+变色 

                2-1-4.cur为par的左子树，且par为gra的右子树（cur在左内侧）

                        2-1-4-1.unc无关

        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        

        此时cur在左内测，先对par和cur使用一次左单旋：

        与2-1-3相比，虽然par和cur的位置不一样，但是par和cur都是红色，将par视作cur，cur视作par之后，它就变成了2-1-3的情况了。

        所以接下来进行右单旋+变色即可。

        之前就行进行了一次左单旋，所以cur在左内侧的情况使用右左双旋+cur和gra互变颜色。

                2-1-5.cur为par的右子树，且par为gra的左子树(cur在右内侧)

                        2-1-5-1.unc无关

        此时cur在右内侧，所以使用右左双旋+cur和gra互变颜色。

        最后是par为黑的情况。

                2-1-6.par为黑

        此时不用做任何改变，因为cur本来就是红色，不违反任何规则。

        总结：

        综上，其实一共就两种情况：

        （1）par为红时：一定有一个黑色的gra，unc为变量

                a.unc为红：

                          Ⅰ.par、unc变黑，gra变红 继续向上调整

                b.unc为黑/不存在：

                          Ⅰ.cur在外侧：单旋+par、gra变色  然后直接结束

                          Ⅱ .cur在内侧：双旋+cur、gra变色  然后直接结束

        （2）par为黑时：直接结束     

        同搜索二叉树，使用替代法：C++-第十章：搜索二叉树-CSDN博客

第三节：代码实现

        将总结整理成代码。

        2-1.Node类

         使用枚举enum对节点进行"红"、"黑"分类，并且节点初始为"红"：

	enum NodeType
	{
		RED = 0,
		BLACK = 1
	};
	template<class T>
	class Node
	{
	public:
		Node<T>* _left = nullptr;
		Node<T>* _right = nullptr;
		Node<T>* _parent = nullptr;
		T val;
		NodeType _type = RED;
	};

        2-2.RBTree类

        这里直接给出核心代码：

namespace zd
{
	template<class T>
	class RBTree
	{
	public:
		// 插入函数
		void Insert(const T& val)
		{
			// 没有节点就初始化根节点
			if (_root == nullptr)
			{
				_root = new Node<T>;
				_root->_val = val;
				// 记得根的颜色一定是黑
				_root->_type = BLACK;
			}

			Node<T>* cur = _root;
			Node<T>* parent = nullptr;
			while (cur)
			{
				if (cur->_val < val)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_val > val)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 不允许存储重复的val
					return;
				}
			}

			cur = new Node<T>;
			cur->_val = val;
			if (parent->_val > cur->_val)
			{
				parent->_left = cur;	
			}
			else
			{
				parent->_right = cur;
			}
			cur->_parent = parent;

			// 使红黑树符合规则
			Balance(cur);
		}

		void _Print(Node<T>* root)
		{
			if (root == nullptr) return;
			_Print(root->_left);
			std::cout << root->_val << " ";
			_Print(root->_right);
		}
		// 中序遍历打印
		void Print()
		{
			_Print(_root);
		}
	private:
		// 平衡红黑树
		void Balance(Node<T>* cur)
		{
			// 只有上一个gra才可以递归到根，将根变为黑色并退出
			if (cur == _root)
			{
				_root->_type = BLACK;
				return;
			}

			Node<T>* par = cur->_parent;
			if (par->_type == BLACK) // 黑色直接结束
			{
				return;
			}
			else // 红色
			{
				Node<T>* gra = par->_parent;
				Node<T>* unc;
				if (par == gra->_left)
					unc = gra->_right;
				else
					unc = gra->_left;

				// unc存在且为红
				if (unc && unc->_type == RED)
				{
					// par、unc变黑
					par->_type = unc->_type = BLACK;
					// gra变红
					gra->_type = RED;
					// 递归调用自己,继续向上调整
					Balance(gra);
				}
				// unc为黑/不存在 && cur在左外侧
				else if (cur == par->_left && par == gra->_left)
				{
					RotateR(gra); // 右单旋
					// 变色
					par->_type = BLACK;
					gra->_type = RED;
					return;
				}
				// unc为黑/不存在 && cur在右外侧
				else if (cur == par->_right && par == gra->_right)
				{
					RotateL(gra); // 左单旋
					// 变色
					par->_type = BLACK;
					gra->_type = RED;
					return;
				}
				// unc为黑/不存在 && cur在左内侧
				else if (cur == par->_right && par == gra->_left)
				{
					RotateLR(gra); // 左右双旋
					// 变色
					cur->_type = BLACK;
					gra->_type = RED;
					return;
				}
				// unc为黑/不存在 && cur在右内侧
				else if (cur == par->_left && par == gra->_right)
				{
					RotateRL(gra); // 右左双旋
					// 变色
					cur->_type = BLACK;
					gra->_type = RED;
					return;
				}
			}
		}
		// 右单旋
		void RotateR(Node<T>* gra)
		{
			Node<T>* par = gra->_left;
			gra->_left = par->_right;
			if (gra->_left)
				gra->_left->_parent = gra;

			par->_right = gra;
			// 正确连接par和gra的父亲
			if (gra == _root)
			{
				_root = par;
			}
			else
			{
				if (gra->_parent->_left == gra)
					gra->_parent->_left = par;
				else
					gra->_parent->_right = par;
			}

			par->_parent = gra->_parent;
			gra->_parent = par;
		}
		// 左单旋
		void RotateL(Node<T>* gra)
		{
			Node<T>* par = gra->_right;
			gra->_right = par->_left;
			if (gra->_right)
				gra->_right->_parent = gra;

			par->_left = gra;
			// 正确连接par和gra的父亲
			if (gra == _root)
			{
				_root = par;
			}
			else
			{
				if (gra->_parent->_left == gra)
					gra->_parent->_left = par;
				else
					gra->_parent->_right = par;
			}

			par->_parent = gra->_parent;
			gra->_parent = par;
		}
		// 左右双旋
		void RotateLR(Node<T>* gra)
		{
			Node<T>* par = gra->_left;
			RotateL(par);
			RotateR(gra);
		}
		// 右左双旋
		void RotateRL(Node<T>* gra)
		{
			Node<T>* par = gra->_right;
			RotateR(par);
			RotateL(gra);
		}
		private:
		Node<T>* _root = nullptr;
	};
};

        我们还需要一个函数来验证红黑树，验证规则如下：

        （1）根为黑

        （2）任意红色节点的父亲为黑

        （3）以任意节点为起点，到叶子节点的路径上的黑色节点数量相等

                方法：每个节点记录最左路径上的黑色节点数量为标准，其他路径和它不一样，那就说明不是红黑树。

        

        将上述规则实现成代码：

		// 验证红黑树
		bool IsRBTree()
		{
			// 验证根的颜色
			if (_root->_type == RED)
				return false;
			// 检查红节点的父亲都是黑节点
			bool ret1 = RedOfBlack(_root);
			// 遍历树,每个节点检查自己的路径上的黑色节点是否相同
			bool ret2 = BlackIsEq(_root);
			if (ret1 == false)
				printf("出现连续红\n");
			if (ret2 == false)
				printf("黑色数量不一致\n");
			return ret1 && ret2;
		}

		// 检查连续红节点
		bool RedOfBlack(Node<T>* root)
		{
			if (root == nullptr) return true;
			// 验证红色节点的父亲为黑色
			if (root->_type == RED)
			{
				if (root->_parent->_type == RED)
					return false;
			}
			return RedOfBlack(root->_left) && RedOfBlack(root->_right);
		}

		// 检查路径黑节点数量
		bool BlackIsEq(Node<T>* root)
		{
			if (root == nullptr) return true;
			// 获得最左路径黑节点数量
			int Bc = 0;
			Node<T>* cur = root;
			while (cur)
			{
				if (cur->_type == BLACK)
					Bc++;
				cur = cur->_left;
			}
			int otherPath = root->_type == BLACK ? 1 : 0; // 其他路径的节点数量
			return _BlackIsEq(root->_left,Bc,otherPath) && _BlackIsEq(root->_right, Bc, otherPath);
		}
		bool _BlackIsEq(Node<T>* root, int Bc, int oP)
		{
			if (root == nullptr)
			{
				if (Bc == oP) return true;
				return false;
			}
			if (root->_type == BLACK)
			{
				oP++;
			}
			return _BlackIsEq(root->_left, Bc, oP) && _BlackIsEq(root->_right,Bc,oP);
		}

 Gitee：红黑树 · 转调/C++ - 码云 - 开源中国

第四节：测试

        生成多个随机数进行测试即可：

#include "RBTree.hpp"
#include <time.h>
int main()
{
	zd::RBTree<int> tree;
	srand(time(nullptr));
	int i = 100;
	while (i--)
	{
		int x = rand();
		tree.Insert(x);
	}
	tree.Print();

	std::cout << tree.IsRBTree() << std::endl;
	return 0;
}

下期预告：

        第十四章将学习哈希表的原理，并自己实现一个简单的哈希表。

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

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

相关文章

推荐3个背景渐变色的wordpress主题

推荐3个背景渐变色的wordpress主题

干净、清爽、背景渐变色的wordpress企业主题 ​ 服务类公司wordpress企业主题https://www.jianzhanpress.com/?p8255 红色大气的wordpress企业主题&#xff0c;适合服务行业的公司搭建企业官方网站使用。 ​ wordpress询盘型独立站主题https://www.jianzhanpress.com/?p8258…
阅读更多...
Scrapy：隧道代理中移除 Proxy-Authorization 的原理解析

Scrapy：隧道代理中移除 Proxy-Authorization 的原理解析

隧道代理中移除 Proxy-Authorization 的原理解析 背景 在 Scrapy 的 HTTP 下载处理中&#xff0c;当使用隧道代理&#xff08;TunnelingAgent&#xff09;时&#xff0c;会移除请求头中的 Proxy-Authorization。这个操作看似简单&#xff0c;但背后有着重要的安全考虑和技术原…
阅读更多...
微信小程序-二维码绘制

微信小程序-二维码绘制

wxml <view bindlongtap"saveQrcode"><!-- 二维码 --><view style"position: absolute;background-color: #FFFAEC;width: 100%;height: 100vh;"><canvas canvas-id"myQrcode" style"width: 200px; height: 200px;ba…
阅读更多...
Fiddler 的安装与使用

Fiddler 的安装与使用

目录 1、Fiddler 的安装2、Fiddler 的使用 1、Fiddler 的安装 通过Fiddler 官网进行下载&#xff08;下载免费的经典版本&#xff09;&#xff0c;填写用途、邮箱、国家信息即可开始下载。 Fiddler 官网下载链接 双击安装包即可进行安装&#xff0c;显示以下界面说明安装成功。…
阅读更多...
Hadoop架构详解

Hadoop架构详解

Hadoop 是一个开源的分布式计算系统&#xff0c;用于存储和处理大规模数据集。Hadoop 主要由HDFS&#xff08;Hadoop Distributed File System&#xff09;、MapReduce、Yarn&#xff08;Jobtracker&#xff0c;TaskTracker&#xff09;三大核心组件组成。其中HDFS是分布式文件…
阅读更多...
清华大学DeepSeek文档下载，清华大学deepseek下载（完成版下载）

清华大学DeepSeek文档下载，清华大学deepseek下载（完成版下载）

文章目录 前言一、清华大学DeepSeek使用手册下载二、清华大学DeepSeek使用手册思维导图 前言 这是一篇关于清华大学deepseek使用手册pdf的介绍性文章&#xff0c;主要介绍了DeepSeek的定义、功能、使用方法以及如何通过提示语设计优化AI性能。以下是对这些核心内容的简要概述&…
阅读更多...
Hadoop第2课（伪分布式集群的搭建）

Hadoop第2课（伪分布式集群的搭建）

jdk和hadoop安装包&#xff1a; hadoop-2.9.2.t......等2个文件官方版下载丨最新版下载丨绿色版下载丨APP下载-123云盘 1、用XFTP发送hadoop安装包和jdk到/home/hadoop/目录下&#xff08;hadoop用户的主目录&#xff09; 2、解压jdk安装包到~目录 卸载jdk的命令&#xff1a;r…
阅读更多...
使用Crawlee可破题js渲染采集数据

使用Crawlee可破题js渲染采集数据

使用 Crawlee 实现自动化爬虫流程 1. Crawlee 简介 Crawlee 是一个强大的爬虫框架&#xff0c;用于快速构建和维护可靠的爬虫。它支持多种爬虫类型&#xff0c;包括基于 Cheerio 和 Playwright 的爬虫&#xff0c;能够高效处理静态和动态网页。 2. 项目目标 通过自动化脚本实…
阅读更多...
Fiddler在Windows下抓包Https

Fiddler在Windows下抓包Https

文章目录 1.Fiddler Classic 配置2.配置浏览器代理自动代理手动配置浏览器代理 3.抓取移动端 HTTPS 流量&#xff08;可选&#xff09;解决抓取 HTTPS 失败问题1.Fiddler证书过期了 默认情况下&#xff0c;Fiddler 无法直接解密 HTTPS 流量。需要开启 HTTPS 解密&#xff1a; 1…
阅读更多...
Java语法基础知识点1

Java语法基础知识点1

目录 一、数组 1.1数组的初始化&#xff1a; 1.2数组的遍历方法&#xff1a; 1.3数组的常见使用方法&#xff1a; 二、类和对象 2.1构造方法&#xff1a; 2.2this关键字: 三、封装 3.1访问限定符&#xff1a; 3.2static关键字&#xff1a; 3.3代码块&#xff1a; 一…
阅读更多...
【新手入门】SQL注入之盲注

【新手入门】SQL注入之盲注

一、引言 在我们的注入语句被带入数据库查询但却什么都没有返回的情况我们该怎么办? 例如应用程序返回到一个"通用的"的页面&#xff0c;或者重定向一个通用页面(可能为网站首页)。这时&#xff0c;我们之前学习的SQL注入的办法就无法使用了。这种情况我们称之为无…
阅读更多...
python-leetcode-分割等和子集

python-leetcode-分割等和子集

416. 分割等和子集 - 力扣&#xff08;LeetCode&#xff09; class Solution:def canPartition(self, nums: List[int]) -> bool:total sum(nums)if total % 2 ! 0:return Falsetarget total // 2dp [False] * (target 1)dp[0] Truefor num in nums:for j in range(tar…
阅读更多...
趣讲TCP三次握手

趣讲TCP三次握手

一、TCP三次握手简介 TCP&#xff08;Transmission Control Protocol&#xff0c;传输控制协议&#xff09;是一种面向连接的、可靠的、基于字节流的传输层通信协议。在TCP连接中&#xff0c;只有两方进行通信&#xff0c;它使用校验和、确认和重传机制来保证数据的可靠传输。…
阅读更多...
基于coze+微信小程序实现图片上传并利用大模型解析

基于coze+微信小程序实现图片上传并利用大模型解析

项目截图&#xff1a; 实现代码&#xff08;直接搬去可用&#xff09; 前提&#xff1a;需要填写你的oss配置coze的api授权配置&#xff01;&#xff01;&#xff01; <template><view class"container"><!-- 高斯模糊背景 --><view class&qu…
阅读更多...
VMware Fusion 虚拟机Mac版 安装CentOS 7 系统

VMware Fusion 虚拟机Mac版 安装CentOS 7 系统

介绍 CentOS是Community Enterprise Operating System的缩写&#xff0c;也叫做社区企业操作系统。是企业Linux发行版领头羊Red Hat Enterprise Linux的再编译版本&#xff08;是一个再发行版本&#xff09;&#xff0c;而且在RHEL的基础上修正了不少已知的 Bug &#xff0c;相…
阅读更多...
java练习（44）

java练习（44）

ps:题目来自力扣 两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 // 定义链表节点类&#xff0c;每个节…
阅读更多...
Deepseek 开源周第一天：FlashMLA

Deepseek 开源周第一天：FlashMLA

Deepseek 隆重开启开源周！第一天我们迎来了FlashMLA。我很高兴带大家了解这项创新，揭秘 FlashMLA 为何能成为 AI 和 GPU 优化领域的变革者。 Deepseek 开源周的热门话题有哪些？
阅读更多...
DeepSeek-OpenSourceWeek-第三天-Release of DeepGEMM

DeepSeek-OpenSourceWeek-第三天-Release of DeepGEMM

DeepGEMM：这是一款专为高效的 FP8（8 位浮点）通用矩阵乘法（GEMMs）而开发的尖端库。GEMMs 是许多 AI 工作负载（尤其是深度学习）中的基本操作。 特点： 支持稠密和 MoE GEMMs：它可以处理标准的稠密矩阵乘法以及混合专家（MoE）模型中使用的矩阵乘法。MoE 是一种神经网络架…
阅读更多...
Bitlocker取证之PXE降级取密钥

Bitlocker取证之PXE降级取密钥

支持到微软Surface pro系列。
阅读更多...
.Net Core Visual Studio NuGet.Config 配置参考

.Net Core Visual Studio NuGet.Config 配置参考

Visual Studio 2022 NUGET NU1301 无法加载源 基础连接已关闭&#xff1a;无法建立SSL / TLS安全通道的信任关系&#xff1b;根据验证过程&#xff0c;远程证书无效&#xff0c;参考文章&#xff1a;https://blog.csdn.net/hefeng_aspnet/article/details/145780081 NuGet 行为…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023