高阶数据结构与算法——红黑树の奥秘

news2024/11/24 17:16:50

1.认识红黑树

1.1红黑树的概念

红⿊树是⼀棵⼆叉搜索树，他的每个结点增加⼀个存储位来表⽰结点的颜⾊，可以是红⾊或者⿊⾊。通过对任何⼀条从根到叶⼦的路径上各个结点的颜⾊进⾏约束，红⿊树确保没有⼀条路径会⽐其他路径⻓出2倍，因⽽是接近平衡的

1.2红黑树的规则

1. 每个结点不是红⾊就是⿊⾊

2. 根结点是⿊⾊的

3. 如果⼀个结点是红⾊的，则它的两个孩⼦结点必须是⿊⾊的，也就是说任意⼀条路径不会有连续的红⾊结点

4. 对于任意⼀个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的⿊⾊结点

1.2红黑树的效率:O(logN)

红⿊树的表达相对AVL树要抽象⼀些，AVL树通过⾼度差直观的控制了平衡。红⿊树通过4条规则的颜 ⾊约束，间接的实现了近似平衡，他们效率都是同⼀档次，但是相对⽽⾔，插⼊相同数量的结点，红⿊树的旋转次数是更少的，因为他对平衡的控制没那么严格

2.红黑树的实现

2.1红黑树的基本框架

enum Colour
{
	RED,
	BLACK
};

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

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

template<class K,class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
private:
	Node* _root = nullptr;
};

2.2红黑树的插入

1. 插⼊⼀个值按⼆叉搜索树规则进⾏插⼊，插⼊后我们只需要观察是否符合红⿊树的4条规则

2. 如果是空树插⼊，新增结点是⿊⾊结点。如果是⾮空树插⼊，新增结点必须红⾊结点，因为⾮空树插⼊，新增⿊⾊结点就破坏了规则4，规则4是很难维护的

3. ⾮空树插⼊后，新增结点必须红⾊结点，如果⽗亲结点是⿊⾊的，则没有违反任何规则，插⼊结束

4. ⾮空树插⼊后，新增结点必须红⾊结点，如果⽗亲结点是红⾊的，则违反规则3。进⼀步分析，c是红⾊，p为红，g必为⿊，这三个颜⾊都固定了，关键的变化看u的情况，需要根据u分为以下⼏种 情况分别处理。 说明：下图中假设我们把新增结点标识为c(cur)，c的⽗亲标识为p(parent)，p的⽗亲标识为 g(grandfather)，p的兄弟标识为u（uncle）   

2.2.1变色

c为红，p为红，g为⿊，u存在且为红，则将p和u变⿊，g变红。在把g当做新的c，继续往上更新分析：因为p和u都是红⾊，g是⿊⾊，把p和u变⿊，左边⼦树路径各增加⼀个⿊⾊结点，g再变红，相 当于保持g所在⼦树的⿊⾊结点的数量不变，同时解决了c和p连续红⾊结点的问题，需要继续往上更新是因为，g是红⾊，如果g的⽗亲还是红⾊，那么就还需要继续处理；如果g的⽗亲是⿊⾊，则处理结束了；如果g就是整棵树的根，再把g变回⿊⾊

2.2.2变色+单旋

c为红，p为红，g为⿊，u不存在或者u存在且为⿊，u不存在，则c⼀定是新增结点，u存在且为⿊，则c⼀定不是新增，c之前是⿊⾊的，是在c的⼦树中插⼊，符合情况1，变⾊将c从⿊⾊变成红⾊，更新上来的。 分析：p必须变⿊，才能解决，连续红⾊结点的问题，u不存在或者是⿊⾊的，这⾥单纯的变⾊⽆法解决问题，需要旋转+变⾊

如果p是g的左，c是p的左，那么以g为旋转点进⾏右单旋，再把p变⿊，g变红即可。p变成课这颗树新的根，这样⼦树⿊⾊结点的数量不变，没有连续的红⾊结点了，且不需要往上更新，因为p的⽗亲是⿊⾊还是红⾊或者空都不违反规则

如果p是g的右，c是p的右，那么以g为旋转点进⾏左单旋，再把p变⿊，g变红即可。p变成课这颗树新的根，这样⼦树⿊⾊结点的数量不变，没有连续的红⾊结点了，且不需要往上更新，因为p的⽗亲是⿊⾊还是红⾊或者空都不违反规则

2.2.3变色+双旋

c为红，p为红，g为⿊，u不存在或者u存在且为⿊，u不存在，则c⼀定是新增结点，u存在且为⿊，则 c⼀定不是新增，c之前是⿊⾊的，是在c的⼦树中插⼊，符合情况1，变⾊将c从⿊⾊变成红⾊，更新上来的。 分析：p必须变⿊，才能解决，连续红⾊结点的问题，u不存在或者是⿊⾊的，这⾥单纯的变⾊⽆法解决问题，需要旋转+变⾊

如果p是g的左，c是p的右，那么先以p为旋转点进⾏左单旋，再以g为旋转点进⾏右单旋，再把c变 ⿊，g变红即可。c变成课这颗树新的根，这样⼦树⿊⾊结点的数量不变，没有连续的红⾊结点了，且不需要往上更新，因为c的⽗亲是⿊⾊还是红⾊或者空都不违反规则

如果p是g的右，c是p的左，那么先以p为旋转点进⾏右单旋，再以g为旋转点进⾏左单旋，再把c变⿊，g变红即可。c变成课这颗树新的根，这样⼦树⿊⾊结点的数量不变，没有连续的红⾊结点了，且不需要往上更新，因为c的⽗亲是⿊⾊还是红⾊或者空都不违反规则

2.3验证一棵树是否为红黑树

规则1：枚举颜⾊类型，天然实现保证了颜⾊不是⿊⾊就是红⾊。

规则2：直接检查根即可

规则3：前序遍历检查，遇到红⾊结点查孩⼦不太⽅便，因为孩⼦有两个，且不⼀定存在，反过来检 查⽗亲的颜⾊就⽅便多了。

规则4：前序遍历，遍历过程中⽤形参记录跟到当前结点的blackNum(⿊⾊结点数量)，前序遍历遇到 ⿊⾊结点就++blackNum，⾛到空就计算出了⼀条路径的⿊⾊结点数量。再任意⼀条路径⿊⾊结点数量作为参考值，依次⽐较即可 

bool Check(Node* root, int blacknum, const int retnum)
{
	if (root == nullptr)
	{
		if (blacknum != retnum)
		{
			cout << "有路径的黑色节点个数与其他路径不相同" << endl;
			return false;
		}
		return true;
	}

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

	if (root->_col == BLACK)
	{
		blacknum++;
	}

	return Check(root->_left, blacknum, retnum)
		&& Check(root->_right, blacknum, retnum);
}
bool IsBalance()
{
	if (_root == nullptr)
	{
		return true;
	}

	if (_root->_col == BLACK)
	{
		return false;
	}

	int retnum = 0;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_col == BLACK)
		{
			retnum++;
		}
		cur = cur->_left;
	}

	return Check(_root, 0, retnum);
}

所有代码如下 

#pragma once
#include<iostream>

enum Colour
{
	RED,
	BLACK
};

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

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

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->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		cur->_col = RED;
		if (cur->_parent.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		//当父节点存在且是红色
		while (parent && parent->_col == RED)
		{
			//当父节点为爷爷节点的左节点
			//     g
			//   p    u
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				//当叔叔节点存在且也为红色，则将父节点与叔叔节点均置为红色
				//将爷爷节点置为黑色，然后向上依次处理
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				//叔叔节点不存在或者叔叔节点为黑色
				//需要旋转+变色
				else
				{
					//    g
					//  p    u
					//c
					//新增节点在父节点左边
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
						//    p
						//c       g
						//            u
					}
					//    g
					//  p    u
					//    c
					else
					{
						RotateL(parent);
						//     g
						//   c    u
						//p
						RotateR(grandfather);
						//     c
						//  p      g
						//             u
						grandfather->_col = RED;
						cur->_col = BLACK;
					}
					break;
				}
			}
			//父节点在爷爷节点的右边
			//      g
			//   u      p
			else
			{
				//当叔叔节点存在且为红色
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					//将叔叔节点与父亲节点置为黑色，爷爷节点置为红色
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;

					//向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//当叔叔节点不存在或者存在但为黑色
				else
				{
					//     g
					// u       p
					//             c
					if (cur == parent->_right)
					{
						RorateL(grandfather);
						//左旋
						//      p
						//   g     c
						//u
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//     g
					// u       p
					//      c
					else
					{
						//右旋
						RotateR(parent);
						//   g
						//u     c
						//         p
						//左旋
						RotateL(grandfather);
						//     c
						//   g    p
						//u
						grandfather->_col = RED;
						cur->_col = BLACK;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	//右单旋
	void RotateR(Node* parent)
	{
		//subL代表根节点的左子树,subLR则代表该左子树的右子树
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		//避免访问空节点
		if (subLR)
		{
			subLR->_parent = parent;
		}

		//如果传入的根节点是一个子树的根节点则需要将旋转后的根节点重新接入原来的节点
		Node* pParent = parent->_parent;

		//换根,将原来根节点的左节点换为根节点
		subL->_right = parent;
		parent->_parent = subL;

		if (pParent == nullptr)
		{
			_root = subL;
			//根节点的父亲节点为空
			subL->_parent = nullptr;
		}
		else
		{
			if (pParent->_left == parent)
			{
				pParent->_left = subL;
			}
			else
			{
				pParent->_right = subL;
			}
			//重新接入原来的节点
			subL->_parent = pParent;
		}
	}

	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

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

		Node* pParent = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

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

	bool IsBalance()
	{
		if (_root == nullptr)
		{
			return true;
		}

		if (_root->_col == BLACK)
		{
			return false;
		}

		int retnum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				retnum++;
			}
			cur = cur->_left;
		}

		return Check(_root, 0, retnum);
	}
private:
	bool Check(Node* root, int blacknum, const int retnum)
	{
		if (root == nullptr)
		{
			if (blacknum != retnum)
			{
				cout << "有路径的黑色节点个数与其他路径不相同" << endl;
				return false;
			}
			return true;
		}

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

		if (root->_col == BLACK)
		{
			blacknum++;
		}

		return Check(root->_left, blacknum, retnum)
			&& Check(root->_right, blacknum, retnum);
	}
private:
	Node* _root = nullptr;
};

 

 

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

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

相关文章

graphrag学习总结

graphrag学习总结

学习视频&#xff1a;b站链接 项目链接 GraphRAG 的基本概念 Document&#xff08;文档&#xff09;&#xff1a;系统中的输入文档。这些文档要么代表CSV中的单独行&#xff0c;要么代表单独的txt文件。 TextUnit&#xff08;文本块&#xff09;&#xff1a;要分析的文本块。…
阅读更多...
pdf阅读软件有哪些？5个软件帮助你快速进行pdf阅读

pdf阅读软件有哪些？5个软件帮助你快速进行pdf阅读

pdf阅读软件有哪些&#xff1f;5个软件帮助你快速进行pdf阅读 如果你正在寻找优秀的PDF阅读软件&#xff0c;以下推荐的5款软件能够帮助你快速、轻松地阅读和管理PDF文件。这些工具各具特色&#xff0c;适用于不同的使用需求&#xff0c;无论是注释、签名、还是管理大文件&…
阅读更多...
使用Rollup.js快速开始构建一个前端项目

使用Rollup.js快速开始构建一个前端项目

Rollup 是一个用于 JavaScript 项目的模块打包器&#xff0c;它将小块代码编译成更大、更复杂的代码&#xff0c;例如库或应用程序。Rollup 对代码模块使用 ES6 模块标准&#xff0c;它支持 Tree-shaking&#xff08;摇树优化&#xff09;&#xff0c;可以剔除那些实际上没有被…
阅读更多...
lwip多线程使用说明，注意事项

lwip多线程使用说明，注意事项

lwIP: Common pitfalls 相关问题&#xff1a; lwIP - A Lightweight TCP/IP stack - Bugs: bug #56531, Missing locking in tcp_input() [Savannah] 我也碰到了差不多情况
阅读更多...
goDoH：一款使用了DNS-over-HTTPS作为传输端口的C2框架

goDoH：一款使用了DNS-over-HTTPS作为传输端口的C2框架

工具介绍 goDoH是一款概念验证命令与控制框架&#xff0c;该工具采用Golang开发&#xff0c;并使用了DNS-over-HTTP作为传输介质。 项目依赖 goDoH的代码构建需要使用到Dep&#xff08;【GitHub传送门】&#xff09;&#xff0c;Dep是一款针对Go语言的依赖管理工具。 在mac…
阅读更多...
【vue】vue-router_ vue3路由管理器

【vue】vue-router_ vue3路由管理器

代码获取 vue-router_ vue3路由管理器 ⼀、基本介绍 1. 单⻚应⽤程序介绍 1.1 概念 单⻚应⽤程序&#xff1a;SPA(Single Page Application)是指所有的功能都在⼀个HTML⻚⾯上实现 1.2 具体⽰例 单⻚应⽤⽹站&#xff1a; ⽹易云⾳乐 https://music.163.com/ 多⻚应⽤⽹…
阅读更多...
【Python语言进阶(二)】

【Python语言进阶(二)】

一、函数的使用方式 将函数视为“一等公民” 函数可以赋值给变量函数可以作为函数的参数函数可以作为函数的返回值 高阶函数的用法&#xff08;filter、map以及它们的替代品&#xff09; items1 list(map(lambda x: x ** 2, filter(lambda x: x % 2, range(1, 10)))) # filter…
阅读更多...
K8s简介和安装部署

K8s简介和安装部署

一、 Kubernetes 简介及部署方法 1、应用部署方式演变 Kubernetes简称为K8s&#xff0c;是用于自动部署、扩缩和管理容器化应用程序的开源系统&#xff0c;起源于Google 集群管理工具Borg。 传统部署 &#xff1a;互联网早期&#xff0c;会直接将应用程序部署在物理机上 优…
阅读更多...
python yolov8半自动标注

python yolov8半自动标注

首先标注一部分图片&#xff0c;进行训练&#xff0c;生成模型&#xff0c;标注文件为xml方便后面统一做处理。 1、标注数据&#xff08;文件为xml, 转为txt用于训练&#xff0c;保留xml标签文件&#xff09; 2、模型训练&#xff08;训练配置、训练代码、&#xff09; 3、使用…
阅读更多...
400行程序写一个实时操作系统（八）：（必看！）使用gdb调试错误的程序

400行程序写一个实时操作系统（八）：（必看！）使用gdb调试错误的程序

上一篇笔者讲完了内存管理算法的完整实现&#xff0c;不过差点忘了&#xff0c;直接上这一部分是不是有点不友好&#xff0c;要知道笔者当初写内存算法可是调试得死去活来&#xff0c;奇奇怪怪的问题不断出现。 就比如笔者当初写了一个内存池算法&#xff0c;结果奇葩的事情发…
阅读更多...
大模型之三十二-语音合成TTS(coqui) 之二 fine-tune

大模型之三十二-语音合成TTS(coqui) 之二 fine-tune

在 大模型之三十-语音合成TTS(coqui)[shichaog CSDN]中提到了xttsv2的fine-tune。 数据情况&#xff1a; 我是从bilibili up主小Lin说提取了一些视频&#xff0c;然后进行了重新的fine-tune。 训练结果 如下图所示&#xff0c;上面波形幅度较大的是xttsv2原始模型的结果&am…
阅读更多...
u盘被写保护怎么解除？u盘写保护怎么去掉？

u盘被写保护怎么解除？u盘写保护怎么去掉？

我们平时在使用U盘的过程中&#xff0c;可能会遇到U盘无法写入文件、删除数据或是格式化的情况。同时还可能收到提示“改磁盘已写保护”。U盘被写保护可能是有意的设置&#xff0c;也可能是无疑的操作。那么U盘被写保护了该怎么解除呢&#xff1f;本期内容&#xff0c;我们将介…
阅读更多...
最新版 Winows下如何安装Redis？

最新版 Winows下如何安装Redis？

最新版 Winows下如何安装Redis&#xff1f; 一、Redis介绍 Redis是一个广泛使用的开源非关系型数据库&#xff0c;它在现代软件开发中扮演着重要角色。**作为一个基于内存的数据库&#xff0c;Redis的底层代码是用ANSI C编写的&#xff0c;这使得它在性能上非常出色。**Redis…
阅读更多...
【AIF-C01认证】亚马逊云科技生成式 AI 认证正式上线啦

【AIF-C01认证】亚马逊云科技生成式 AI 认证正式上线啦

文章目录 一、AIF-C01简介二、考试概览三、考试知识点3.1 AI 和 ML 基础知识3.2 生成式人工智能基础3.3 基础模型的应用3.4 负责任 AI 准则3.5 AI 解决方案的安全性、合规性和监管 四、备考课程4.1 「备考训练营」 在线直播课4.2 「SkillBuilder」学习课程 五、常见问题六、参考…
阅读更多...
前端开发攻略---使用ocr识别图片进行文字提取功能

前端开发攻略---使用ocr识别图片进行文字提取功能

1、引入资源 通过链接引用 <script src"https://cdn.bootcdn.net/ajax/libs/tesseract.js/5.1.0/tesseract.min.js"></script> npm或其他方式下载 npm i tesseract 2、示例 <!DOCTYPE html> <html lang"en"><head><meta…
阅读更多...
从纸质到云端：3C产品说明书的电子化进程与影响

从纸质到云端：3C产品说明书的电子化进程与影响

在科技日新月异的今天&#xff0c;3C产品&#xff08;计算机类、通信类和消费类电子产品&#xff09;作为现代生活不可或缺的一部分&#xff0c;其说明书的演变也见证了技术进步的足迹。从最初的纸质文档到如今的电子说明书&#xff0c;这一转变不仅仅是物理形态的转换&#xf…
阅读更多...
UE5 圆周运动、贝塞尔曲线运动、贝塞尔曲线点

UE5 圆周运动、贝塞尔曲线运动、贝塞尔曲线点

圆周运动 贝塞尔曲线路径运动 蓝图函数库创建贝塞尔曲线点 // Fill out your copyright notice in the Description page of Project Settings.#pragma once#include "CoreMinimal.h" #include "Kismet/BlueprintFunctionLibrary.h" #include "MyBlu…
阅读更多...
文件IO知识梳理及练习

文件IO知识梳理及练习

1> 使用fread和fwrite完成两个文件的拷贝&#xff0c;要求源文件和目标文件由外界输入 #include <myhead.h> typedef struct sockaddr_in addr_in_t; typedef struct sockaddr addr_t; typedef struct sockaddr_un addr_un_t; int main(int argc, const char *argv[])…
阅读更多...
使用OpenCV实现基于FisherFaces的人脸识别

使用OpenCV实现基于FisherFaces的人脸识别

引言 随着人工智能技术的发展&#xff0c;人脸识别已经成为日常生活中不可或缺的一部分。在众多的人脸识别算法中&#xff0c;FisherFaces 方法因其简单易用且具有良好的识别效果而备受青睐。本文将详细介绍如何使用Python和OpenCV库实现基于FisherFaces的人脸识别系统&#x…
阅读更多...
Flink On kubernetes

Flink On kubernetes

Apache Flink 是一个分布式流处理引擎&#xff0c;它提供了丰富且易用的API来处理有状态的流处理应用&#xff0c;并且在支持容错的前提下&#xff0c;高效、大规模的运行此类应用。通过支持事件时间&#xff08;event-time&#xff09;、计算状态&#xff08;state&#xff09…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023