使用c++实现红黑树的构建和插入

news2025/2/19 2:59:25

1.红黑树简介：

红黑树实际上和AVL都属于一棵用于存储数据的平衡二叉搜索树，但是这棵树并不是使用平衡因子去维持平衡的，而是结合限制条件对结点标红标黑去让树达到类似平衡的效果。

2.红黑树的限制条件和效率分析：

2.1限制条件

1. 每个结点不是红⾊就是⿊⾊
2. 根结点是⿊⾊的
3. 如果⼀个结点是红⾊的，则它的两个孩⼦结点必须是⿊⾊的，也就是说任意⼀条路径不会有连续的
红⾊结点。
4. 对于任意⼀个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的⿊⾊结点

2.2效率分析

由规则四可以知道每条路径上的黑结点个数相同，那么在极端情况下，最短路径就是全黑，最长路径就是一黑一红，设最短路径长度为h，最长则为2h，2^{h}-1<N<2^{2h}-1,推导可得h基本上就是为一个logn，说明在插入的时候最差的时间复杂度也就为接近2*logn。

3.红黑树构建时的准备：

3.1红黑标记：

3.2红黑树的结点结构设计：

这里每个结点默认都是处理为红色，因为如果你处理成黑色的话，那当别的地方要处理成红色的时候，别的地方要保持规则四就很困难了，因为这个存储结构是一棵树。

3.3红黑树的结构设计：

template<class K, class V>
class rb_tree {
	typedef rb_tree_node<K,V> node;
private:
	node* root_=nullptr;
};

基本上和AVL树很类似。

3.4处理前的插入：

bool insert(const pair<K, V>& kv) {
	if (root_ == nullptr) {
		root_ = new node(kv);
		root_->col = BLACK;//规定的根为黑色
		return true;
	}
	node* cur = root_;//这部分就和别的二叉搜索树一致
	node* parent = 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);
	if (parent->kv_.first > kv.first) {
		parent->left = cur;
	}
	else {
		parent->right = cur;
	}
	cur->parent = parent;

4.对违反规则的地方进行处理：

4.1情况1：

当插入x时，因为红色的子结点必须是黑色的，所以需要进行处理，如果他的叔叔结点是红色的，那么无论他是在6还是15插入，只需要把它的叔叔结点和父亲结点变为黑色，然后再把它的父亲变为红色。那么就能保证规则不被破坏，每条路的黑结点个数都相同。这里并不是就是结束！当变为红色的时候，可能导致上面的规则遭到破坏，也就是它的上方可能是红色的，那么它也得进行类似的处理。

4.2情况2：

当插入位置为在cur且叔叔为黑色或者不存在的时候，通过这样处理之后可以让规则得到满足。也就是进行一次右单选再与情况1进行相同方式的变色。

4.3情况3：

当cur位置为在cur且叔叔为黑色或者不存在的时候，通过这样处理之后可以让规则得到满足。也就是进行一次左单选再右单旋最后与情况1进行相同方式的变色。

这里还存在一种特殊情况，就是有可能根结点会被处理成红色，但是，根结点实际上是不会影响分路上黑结点分布相同的。所以最后只需要把根结点也处理成黑色就能保证规则不会出现问题。

通过这三种情况就能够把所有情况给包含进去了。

4.4代码展示：

	while (parent && parent->col == RED) {//
		node* grandfather = parent->parent;
		if (grandfather->left == parent) {//处理左子树
			if (grandfather->right && grandfather->right->col == RED) {//叔是红色
				parent->col = BLACK;//变色
				grandfather->right->col = BLACK;
				grandfather->col = RED;
				cur = grandfather;//往上接着迭代
				parent = grandfather->parent;
			}
			else {//叔叔不存在或者叔叔为黑色
				if (cur == parent->left) {//只需要单旋就能解决
					rotateR(grandfather);
					grandfather->col = RED;
					parent->col = BLACK;
				}
				else {//需要双旋才能解决
					rotateL(parent);
					rotateR(grandfather);
					grandfather->col = RED;
					parent->col = BLACK;
				}
				break;
			}
		}
		else {
			if (grandfather->left&&grandfather->left->col == RED) {//叔是红色
				parent->col = BLACK;//变色
				grandfather->left->col = BLACK;
				grandfather->col = RED;
				cur = grandfather;//往上接着迭代
				parent = grandfather->parent;
			}
			else {//叔叔不存在或者叔叔为黑色
				if (cur == parent->right) {//只需要单旋就能解决
					rotateL(grandfather);
					grandfather->col = RED;
					parent->col = BLACK;
				}
				else {//需要双旋才能解决
					rotateR(parent);
					rotateL(grandfather);
					grandfather->col = RED;
					parent->col = BLACK;
				}
				break;
			}
		}
		
	}root_->col = BLACK;//最后记得把根结点的颜色变为黑色
	return true;
}

5.完整代码展示：

#include <iostream>
using namespace std;
enum color {
	RED,
    BLACK
};
template<class K,class V>
class rb_tree_node {
public:
	rb_tree_node(const pair<K, V>& kv) :
		kv_(kv)
		, right(nullptr)
		, left(nullptr)
		, parent(nullptr)
		, col (RED){}
	rb_tree_node* right;
	rb_tree_node* left;
	rb_tree_node* parent;
	pair<K, V> kv_;
	color col;
};
template<class K, class V>
class rb_tree {
	typedef rb_tree_node<K,V> node;
public:
	bool insert(const pair<K, V>& kv) {
		if (root_ == nullptr) {
			root_ = new node(kv);
			root_->col = BLACK;
			return true;
		}
		node* cur = root_;
		node* parent = 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);
		if (parent->kv_.first > kv.first) {
			parent->left = cur;
		}
		else {
			parent->right = cur;
		}
		cur->parent = parent;
		while (parent && parent->col == RED) {
			node* grandfather = parent->parent;
			if (grandfather->left == parent) {
				if (grandfather->right && grandfather->right->col == RED) {//叔是红色
					parent->col = BLACK;//变色
					grandfather->right->col = BLACK;
					grandfather->col = RED;
					cur = grandfather;//往上接着迭代
					parent = grandfather->parent;
				}
				else {//叔叔不存在或者叔叔为黑色
					if (cur == parent->left) {//只需要单旋就能解决
						rotateR(grandfather);
						grandfather->col = RED;
						parent->col = BLACK;
					}
					else {//需要双旋才能解决
						rotateL(parent);
						rotateR(grandfather);
						grandfather->col = RED;
						parent->col = BLACK;
					}
					break;
				}
			}
			else {
				if (grandfather->left&&grandfather->left->col == RED) {//叔是红色
					parent->col = BLACK;//变色
					grandfather->left->col = BLACK;
					grandfather->col = RED;
					cur = grandfather;//往上接着迭代
					parent = grandfather->parent;
				}
				else {//叔叔不存在或者叔叔为黑色
					if (cur == parent->right) {//只需要单旋就能解决
						rotateL(grandfather);
						grandfather->col = RED;
						parent->col = BLACK;
					}
					else {//需要双旋才能解决
						rotateR(parent);
						rotateL(grandfather);
						grandfather->col = RED;
						parent->col = BLACK;
					}
					break;
				}
			}
			
		}root_->col = BLACK;
		return true;
	}
	void rotateR(node* parent) {
		node* sub_L = parent->left;
		node* sub_LR = sub_L->right;
		parent->left = sub_LR;
		if (sub_LR) {
			sub_LR->parent = parent;
		}
		sub_L->right = parent;
		if (parent == root_) {
			root_ = sub_L;
		}
		node* ppnode;
		ppnode = parent->parent;
		if (ppnode) {
			if (ppnode->right == parent) {
				ppnode->right = sub_L;
			}
			else {
				ppnode->left = sub_L;
			}
		}
		parent->parent = sub_L;
	}
	void rotateL(node* parent) {
		node* sub_R = parent->right;
		node* sub_RL = sub_R->left;
		parent->right = sub_RL;
		if (sub_RL) {
			sub_RL->parent = parent;
		}
		sub_R->left = parent;
		if (parent == root_) {
			root_ = sub_R;
		}
		node* ppnode;
		ppnode = parent->parent;
		if (ppnode) {
			if (ppnode->right == parent) {
				ppnode->right = sub_R;
			}
			else {
				ppnode->left = sub_R;
			}
		}
		parent->parent = sub_R;
	}
	void inorder() {
		inorder_(root_);
	}
private:
	void inorder_(node* root) {
		if (root == nullptr) {
			return;
		}
		inorder_(root->left);
		cout << root->kv_.first <<" ";
		inorder_(root->right);
	}
	node* root_=nullptr;
};
int main() {
	rb_tree<int, int>tree1;
	tree1.insert({ 2,2 });
	tree1.insert({ 3,2 });
	tree1.insert({ 1,2 });
	tree1.insert({ 5,2 });
	tree1.insert({ 4,2 });
	tree1.insert({ 6,2 });
	tree1.inorder();
	return 0;
}


 

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

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

相关文章

在大型语言模型（LLM）框架内Transformer架构与混合专家（MoE）策略的概念整合

在大型语言模型（LLM）框架内Transformer架构与混合专家（MoE）策略的概念整合

文章目录 传统的神经网络框架存在的问题一. Transformer架构综述1.1 transformer的输入1.1.1 词向量1.1.2 位置编码&#xff08;Positional Encoding&#xff09;1.1.3 编码器与解码器结构1.1.4 多头自注意力机制 二.Transformer分步详解2.1 传统词向量存在的问题2.2 详解编解码…
阅读更多...
Jenkins项目CICD流程

Jenkins项目CICD流程

Jenkins项目流程:1.配置git环境 git config --...2.把前后端的目录初始化位本地工作目录 #git init3.提交到本地git #git add ./ git commit -m "" git tag v14.然后提交到远程git(通过,用户,群组,项目,管理项目)git remote add origin http://...git push -…
阅读更多...
【IDEA】2017版本的使用

【IDEA】2017版本的使用

目录 一、常识 二、安装 1. 下载IDEA2017.exe 2. 安装教程 三、基本配置 1. 自动更新关掉 2. 整合JDK环境 3. 隐藏.idea文件夹和.iml等文件 四、创建Java工程 1. 新建项目 2. 创建包结构&#xff0c;创建类&#xff0c;编写main主函数&#xff0c;在控制台输出内容。…
阅读更多...
Git指南-从入门到精通

Git指南-从入门到精通

代码提交和同步命令 流程图如下&#xff1a; 第零步: 工作区与仓库保持一致第一步: 文件增删改&#xff0c;变为已修改状态第二步: git add &#xff0c;变为已暂存状态 bash $ git status $ git add --all # 当前项目下的所有更改 $ git add . # 当前目录下的所有更改 $ g…
阅读更多...
Spring boot（maven） - Mybatis 超级入门版

Spring boot（maven） - Mybatis 超级入门版

前言&#xff1a; 通过实践而发现真理&#xff0c;又通过实践而证实真理和发展真理。从感性认识而能动地发展到理性认识&#xff0c;又从理性认识而能动地指导革命实践&#xff0c;改造主观世界和客观世界。实践、认识、再实践、再认识&#xff0c;这种形式&#xff0c;循环往…
阅读更多...
Spark 性能优化 （三）：RBO 与 CBO

Spark 性能优化 （三）：RBO 与 CBO

1. RBO 的核心概念 在 Apache Spark 的查询优化过程中&#xff0c;规则优化&#xff08;Rule-Based Optimization, RBO&#xff09; 是 Catalyst 优化器的一个关键组成部分。它主要依赖于一组固定的规则进行优化&#xff0c;而不是基于统计信息&#xff08;如 CBO - Cost-Base…
阅读更多...
读 DeepSeek-R1 论文笔记

读 DeepSeek-R1 论文笔记

DeepSeek-R1&#xff1a;通过强化学习激发大语言模型的推理能力 DeepSeek-AI 摘要 我们推出第一代推理模型DeepSeek-R1-Zero和DeepSeek-R1。DeepSeek-R1-Zero作为无需监督微调(SFT)预训练阶段、直接通过大规模强化学习(RL)训练的基础模型&#xff0c;展现出卓越的推理能力。…
阅读更多...
【Android开发AI实战】选择目标跟踪基于opencv实现——运动跟踪

【Android开发AI实战】选择目标跟踪基于opencv实现——运动跟踪

文章目录 【Android 开发 AI 实战】选择目标跟踪基于 opencv 实现 —— 运动跟踪一、引言二、Android 开发与 AI 的融合趋势三、OpenCV 简介四、运动跟踪原理&#xff08;一&#xff09;光流法&#xff08;二&#xff09;卡尔曼滤波&#xff08;三&#xff09;粒子滤波 五、基于…
阅读更多...
如何保持长久无痛苦的学英语?

如何保持长久无痛苦的学英语?

“无痛苦”学英语&#xff1f; 听起来像天方夜谭&#xff0c;但并非不可能&#xff01; 关键在于&#xff0c;把英语学习变成你生活的一部分&#xff0c;融入你的兴趣和目标&#xff0c; 这样才能摆脱痛苦&#xff0c;享受学习的过程。 1. 兴趣是最好的老师&#xff1a; 找到自…
阅读更多...
Sequence to Sequence model

Sequence to Sequence model

基础模型 基础模型是用RNN模型&#xff0c;前部分是encoder用来寻找法语输入的编码&#xff0c;后半部分是decoder用来生成英文翻译作为输出&#xff0c;每次输出一个单词&#xff0c;直到输出结束标志如EOS。 下面是另一个例子&#xff0c;在CNN模型输出层之前会输出图片的向…
阅读更多...
6.appender

6.appender

文章目录 一、前言二、源码解析AppenderUnsynchronizedAppenderBaseOutputStreamAppenderConsoleAppenderFileAppenderRollingFileAppenderFileNamePattern 三、总结 一、前言 前一篇文章介绍了appender、conversionRule、root和logger节点的解析, 为的是为本篇详细介绍它们的…
阅读更多...
Golang的消息队列架构

Golang的消息队列架构

一、消息队列的定义和作用 消息队列是一种在不同组件之间传递消息的通信机制。它可以解耦系统的各个部分&#xff0c;提高系统的可靠性和扩展性。消息队列可以在系统之间传递消息&#xff0c;并且在消息发送者和消息接收者之间进行异步通信&#xff0c;使得系统可以更加灵活和高…
阅读更多...
GESP5级语法知识（十一）：高精度算法（一）

GESP5级语法知识（十一）：高精度算法（一）

高精度加法&#xff1a; #include<iostream> #include<string> #include<algorithm> using namespace std; const int N501;//高精度数的最长长度 //c[]a[]b[]:高精度加法方案一&#xff1a;对应位相加&#xff0c;同时处理进位 void h_add_1(int a[],int b…
阅读更多...
【前端】 react项目使用bootstrap、useRef和useState之间的区别和应用

【前端】 react项目使用bootstrap、useRef和useState之间的区别和应用

一、场景描述 我想写一个轮播图的程序&#xff0c;只是把bootstrap里面的轮播图拉过来就用上感觉不是很合适&#xff0c;然后我就想自己写自动轮播&#xff0c;因此&#xff0c;这篇文章里面只是自动轮播的部分&#xff0c;没有按键跟自动轮播的衔接部分。 Ps: 本文用的是函数…
阅读更多...
PYYAML反序列化详解

PYYAML反序列化详解

前言 最近看了很多pyyaml反序列化的漏洞利用&#xff0c;但是对漏洞怎么来的&#xff0c;没有进行很详细的分析&#xff0c;所以今天刚好学习一下反序列化的原理 Yaml基本语法 一个 .yml 文件中可以有多份配置文件&#xff0c;用 --- 隔开即可对大小写敏感YAML 中的值&#x…
阅读更多...
LeeCode题库第十八题

LeeCode题库第十八题

项目场景&#xff1a; 给你一个由 n 个整数组成的数组 nums &#xff0c;和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] &#xff08;若两个四元组元素一一对应&#xff0c;则认为两个四元组重复&#xff09;&…
阅读更多...
Zookeeper 和 Redis 哪种更好？

Zookeeper 和 Redis 哪种更好？

目录 前言 &#xff1a; 什么是Zookeeper 和 Redis &#xff1f; 1. 核心定位与功能 2. 关键差异点 (1) 一致性模型 (2) 性能 (3) 数据容量 (4) 高可用性 3. 适用场景 使用 Zookeeper 的场景 使用 Redis 的场景 4. 替代方案 5. 如何选择&#xff1f; 6. 常见误区 7. 总结 前言…
阅读更多...
公然上线传销项目，Web3 的底线已经被无限突破

公然上线传销项目，Web3 的底线已经被无限突破

作者&#xff1a;Techub 热点速递 撰文&#xff1a;Yangz&#xff0c;Techub News 今天早些时候&#xff0c;OKX 将上线 PI 的消息在圈内引起轩然大波&#xff0c;对于上线被板上钉钉为传销盘子的「项目」 &#xff0c;Techub News 联系了 OKX 公关&#xff0c;但对方拒绝置评…
阅读更多...
C语言第18节：自定义类型——联合和枚举

C语言第18节：自定义类型——联合和枚举

1. 联合体 C语言中的联合体&#xff08;Union&#xff09;是一种数据结构&#xff0c;它允许在同一内存位置存储不同类型的数据。不同于结构体&#xff08;struct&#xff09;&#xff0c;结构体的成员各自占有独立的内存空间&#xff0c;而联合体的所有成员共享同一块内存区域…
阅读更多...
解锁网络安全：穿越数字世界的防护密码

解锁网络安全：穿越数字世界的防护密码

个人主页&#xff1a;java之路-CSDN博客(期待您的关注) 目录 网络安全&#xff1a;数字时代的基石 网络安全面面观 &#xff08;一&#xff09;定义与范畴 &#xff08;二&#xff09;发展历程 网络安全面临的威胁 &#xff08;一&#xff09;恶意软件肆虐 &#xff08;二…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023