DS-红黑树(RBTree)

news2024/11/16 7:36:24

一.红黑树

1.1 红黑树的起源

当对对AVL树做一些结构修改的操作时候，性能较为低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。
因此1972年Rudolf Bayer提出的对称二叉B树（Symmetric Binary B-Trees），随后在1978年Leo J. Guibas和Robert Sedgewick的工作中进一步发展和完善，最终形成了现代意义上的红黑树，它通过简单的规则和较少的旋转操作实现了有效的自平衡，广泛应用于各类需要高效查找、插入和删除操作的场合，例如在Java集合框架中的TreeMap和TreeSet类，以及哈希表中解决冲突时采用的链表+红黑树混合结构。

1.2 红黑树的概念

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

红黑树具有以下性质：

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

1.3 红黑树节点的定义

enum Color
{
	RED,
	BLACK
};
 
template<typename T>
struct RBTreeNode
{
	RBTreeNode(const T& data)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}

	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent; //父节点
	
	T _data;
	Color _col; //颜色
};

1.4 红黑树的插入

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步:

  1. 按照二叉搜索的树规则插入新节点。
  2. 检测新节点插入后，红黑树的性质是否造到破坏。
bool insert(const T& data)
{
	if (_root == nullptr)
	{
		_root = new Node(data);
		return true;
	}
	Node* grandparent = nullptr;
	Node* uncle = nullptr;
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		parent = cur;
		if (data < cur->_data)
		{
			cur = cur->_left;
		}
		else if (data > cur->_data)
		{
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(data);
	if (data < parent->_data)
	{
		parent->_left = cur;
	}
	else if (data > parent->_data)
	{
		parent->_right = cur;
	}
	else
	{
		assert(false);
	}
	cur->_parent = parent;
	while (parent && parent->_col == RED)
	{
		grandparent = parent->_parent;
		if (grandparent)
		{
			if (parent == grandparent->_left)
			{
				uncle = grandparent->_right;
			}
			else
			{
				uncle = grandparent->_left;
			}
		}
		else
		{
			break;
		}
		if (uncle && uncle->_col == RED)
		{
			parent->_col = BLACK;
			uncle->_col = BLACK;
			grandparent->_col = RED;
			cur = grandparent;
		}
		else
		{
			cur = Rotate(grandparent, parent, cur);
		}
		parent = cur->_parent;
		_root->_col = BLACK;
	}
	return true;
}

大致思路如下:
以下简称插入节点为cur，cur的父节点为parent，parent的父节点为grandparent，parent的兄弟节点为uncle。

  1. 先先按照二叉搜索树的规则将节点插入到红黑树中，节点颜色为红色。
  2. 插入后，红黑树的性质可能遭到破坏，此时就要根据红黑树的性质进行检测。
  3. cur插入后，如果parent颜色为黑色，则没有破坏红黑树的性质，插入结束。
  4. 若parent为红色，则此时有两种情况(uncle为红，uncle为黑/uncle不存在)
    1. uncle为红时，将parent和uncle变为黑色，grandparent变为红色，然后把grandparent视为cur，继续向上调整。
    2. uncle为黑/uncle不存在时，进行旋转。 (旋转在1.5处详细解释)

1.5 红黑树的旋转

此处的旋转与AVL树的旋转思路较为相似。

当uncle为黑/uncle不存在时，parent为cur的（左/右）孩子且parent为grandparent的（左/右）孩子，进行（右单旋）/（左单旋）。
右单旋

void RotateR(Node* parent)
{
	Node* ppnode = parent->_parent;
	Node* cur = parent->_left;
	Node* cur_right = cur->_right;

	if (ppnode)
	{
		if (ppnode->_left == parent)
		{
			ppnode->_left = cur;
		}
		else if (ppnode->_right == parent)
		{
			ppnode->_right = cur;
		}
		else
		{
			assert(false);
		}
	}
	else
	{
		_root = cur;
	}
	cur->_parent = ppnode;

	parent->_left = cur_right;
	if (cur_right)
	{
		cur_right->_parent = parent;
	}

	cur->_right = parent;
	parent->_parent = cur;
}

左单旋

void RotateL(Node* parent)
{
	Node* ppnode = parent->_parent;
	Node* cur = parent->_right;
	Node* cur_left = cur->_left;

	if (ppnode)
	{
		if (ppnode->_right == parent)
		{
			ppnode->_right = cur;
		}
		else if (ppnode->_left == parent)
		{
			ppnode->_left = cur;
		}
		else
		{
			assert(false);
		}
	}
	else
	{
		_root = cur;
	}
	cur->_parent = ppnode;

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

	cur->_left = parent;
	parent->_parent = cur;
}

当uncle为黑/uncle不存在时，parent为cur的（右/左）孩子且parent为grandparent的（左/右）孩子，进行（右单旋）/（左单旋）。

Node* Rotate(Node* grandparent, Node* parent, Node* cur)
{
	if (parent == grandparent->_left)
	{
		if (cur == parent->_left)
		{
			RotateR(grandparent);
			parent->_col = RED;
			grandparent->_col = BLACK;
			cur->_col = BLACK;
			return parent;
		}
		else
		{
			RotateL(parent);
			RotateR(grandparent);
			parent->_col = BLACK;
			grandparent->_col = BLACK;
			cur->_col = RED;
			return cur;
		}
	}
	else
	{
		if (cur == parent->_left)
		{
			RotateR(parent);
			RotateL(grandparent);
			parent->_col = BLACK;
			grandparent->_col = BLACK;
			cur->_col = RED;
			return cur;
		}
		else
		{
			RotateL(grandparent);
			parent->_col = RED;
			grandparent->_col = BLACK;
			cur->_col = BLACK;
			return parent;
		}
	}

1.6 红黑树的特点与应用

  1. 红黑树是一棵不追求绝对平衡的二叉搜索树，其只需保证最长路径不超过最短路径的2倍，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优。
  2. 红黑树在C++ STL库中 map/set 等结构中充当底层结构，据说在java中哈希表中的哈希桶下的链表长度超过一定的阈值时，也会转换为红黑树提高效率。使得在处理大量冲突键时，极大的缓解了链表过长导致的哈希表查找效率退化。

1.7 完整代码

#pragma once
#include <iostream>
#include <assert.h>
using namespace std;

enum Color
{
	RED,
	BLACK
};
 
template<typename T>
struct RBTreeNode
{
	RBTreeNode(const T& data)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}

	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	
	T _data;
	Color _col;
};

template<typename T>
class RBTree
{
public:


	typedef RBTreeNode<T> Node;
	
	RBTree()
		:_root(nullptr)
	{}

	bool insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			return true;
		}
		Node* grandparent = nullptr;
		Node* uncle = nullptr;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			parent = cur;
			if (data < cur->_data)
			{
				cur = cur->_left;
			}
			else if (data > cur->_data)
			{
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(data);
		if (data < parent->_data)
		{
			parent->_left = cur;
		}
		else if (data > parent->_data)
		{
			parent->_right = cur;
		}
		else
		{
			assert(false);
		}
		cur->_parent = parent;
		while (parent && parent->_col == RED)
		{
			grandparent = parent->_parent;
			if (grandparent)
			{
				if (parent == grandparent->_left)
				{
					uncle = grandparent->_right;
				}
				else
				{
					uncle = grandparent->_left;
				}
			}
			else
			{
				break;
			}
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandparent->_col = RED;
				cur = grandparent;
			}
			else
			{
				cur = Rotate(grandparent, parent, cur);
			}
			parent = cur->_parent;
			_root->_col = BLACK;
		}
		return true;
	}

	Node* get_Root()
	{
		return _root;
	}

	bool checkColour(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
				return false;

			return true;
		}

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

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

		return checkColour(root->_left, blacknum, benchmark)
			&& checkColour(root->_right, blacknum, benchmark);
	}

	bool isBalance()
	{
		return isBalance(_root);
	}

	int height()
	{
		return height(_root);
	}
private:

	Node* _root;

	void RotateR(Node* parent)
	{
		Node* ppnode = parent->_parent;
		Node* cur = parent->_left;
		Node* cur_right = cur->_right;

		if (ppnode)
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else if (ppnode->_right == parent)
			{
				ppnode->_right = cur;
			}
			else
			{
				assert(false);
			}
		}
		else
		{
			_root = cur;
		}
		cur->_parent = ppnode;

		parent->_left = cur_right;
		if (cur_right)
		{
			cur_right->_parent = parent;
		}

		cur->_right = parent;
		parent->_parent = cur;
	}

	void RotateL(Node* parent)
	{
		Node* ppnode = parent->_parent;
		Node* cur = parent->_right;
		Node* cur_left = cur->_left;

		if (ppnode)
		{
			if (ppnode->_right == parent)
			{
				ppnode->_right = cur;
			}
			else if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				assert(false);
			}
		}
		else
		{
			_root = cur;
		}
		cur->_parent = ppnode;

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

		cur->_left = parent;
		parent->_parent = cur;
	}

	Node* Rotate(Node* grandparent, Node* parent, Node* cur)
	{
		if (parent == grandparent->_left)
		{
			if (cur == parent->_left)
			{
				RotateR(grandparent);
				parent->_col = RED;
				grandparent->_col = BLACK;
				cur->_col = BLACK;
				return parent;
			}
			else
			{
				RotateL(parent);
				RotateR(grandparent);
				parent->_col = BLACK;
				grandparent->_col = BLACK;
				cur->_col = RED;
				return cur;
			}
		}
		else
		{
			if (cur == parent->_left)
			{
				RotateR(parent);
				RotateL(grandparent);
				parent->_col = BLACK;
				grandparent->_col = BLACK;
				cur->_col = RED;
				return cur;
			}
			else
			{
				RotateL(grandparent);
				parent->_col = RED;
				grandparent->_col = BLACK;
				cur->_col = BLACK;
				return parent;
			}
		}
	}

	bool isBalance(Node* root)
	{
		if (root == nullptr)
			return true;

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

		// 基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++benchmark;

			cur = cur->_left;
		}

		return checkColour(root, 0, benchmark);
	}

	int height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = height(root->_left);
		int rightHeight = height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}
};

————————————————————
感谢大家观看，不妨点赞支持一下吧[doge]
如有错误，随时纠正，谢谢大家

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

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

相关文章

循环冗余校验CRC和FPGA实现

循环冗余校验CRC和FPGA实现

一、概念 CRC校验&#xff0c;中文翻译过来是&#xff1a;循环冗余校验&#xff0c;英文全称是&#xff1a;Cyclic Redundancy Check。是一种通过对数据产生固定位数的校验码&#xff0c;以检验数据是否存在错误的技术。 其主要特点是检错能力强、开销小&#xff0c;易于电路实…
阅读更多...
设计模式 --4:工厂方法模式

设计模式 --4:工厂方法模式

总结 &#xff1a; 个人理解&#xff1a; 工厂方法模式就是在简单工程模式的基础下将工厂类抽象出来。如果不抽象工厂类 &#xff0c;每一次创建一个新的算法&#xff0c;都要修改原来的工厂类&#xff0c;这不符合 开放–封闭原则 将工厂类给抽象出来&#xff0c;让具体的算法…
阅读更多...
Node安装，nodejs详细安装步骤

Node安装，nodejs详细安装步骤

什么是nodejs? 脚本语言需要一个解析器才能运行&#xff0c;JavaScript是脚本语言&#xff0c;在不同的位置有不一样的解析器&#xff0c;如写入html的js语言&#xff0c;浏览器是它的解析器角色。而对于需要独立运行的JS&#xff0c;nodejs就是一个解析器。 每一种解析器都是…
阅读更多...
Springboot解决跨域问题方案总结(包括Nginx，Gateway网关等)

Springboot解决跨域问题方案总结(包括Nginx，Gateway网关等)

&#x1f3f7;️个人主页&#xff1a;牵着猫散步的鼠鼠 &#x1f3f7;️系列专栏&#xff1a;Java全栈-专栏 &#x1f3f7;️个人学习笔记&#xff0c;若有缺误&#xff0c;欢迎评论区指正 目录 前言 解决跨域问题方案 1.Spring Boot 中解决跨域 1.1 通过注解跨域 1.2 通…
阅读更多...
行业名称组合商标驳回，要不要做驳回复审！

行业名称组合商标驳回，要不要做驳回复审！

今天一网友问普推知产老杨做驳回复审多少费用&#xff0c;让先发来驳回文件看下&#xff0c;并不是所有商标驳回值得去做驳回复审&#xff0c;因为有的驳回理由去做通过率极低&#xff0c;等于浪费费用和时间。 网友这个申请注册商标名称是英文&#xff0c;翻译过来的是行业常…
阅读更多...
全国大学生数学建模大赛备赛——相关系数的求解（皮尔逊（pearson）、斯皮尔曼（spearman）、肯德尔（kendall）相关系数）

全国大学生数学建模大赛备赛——相关系数的求解（皮尔逊（pearson）、斯皮尔曼（spearman）、肯德尔（kendall）相关系数）

相关系数是用来衡量两个变量之间线性相关程度的指标。它的取值范围在-1到1之间&#xff0c;当相关系数为1时表示两个变量完全正相关&#xff08;即一个变大另一个也变大&#xff09;&#xff0c;当相关系数为-1时表示两个变量完全负相关&#xff08;即一个变大另一个变小&#…
阅读更多...
设计数据库之概念模式：E-R模型

设计数据库之概念模式：E-R模型

Chapter3&#xff1a;设计数据库之概念模式&#xff1a;E-R模型 笔记来源&#xff1a;《漫画数据库》—科学出版社 设计数据库的步骤&#xff1a; 概念模式 概念模式(conceptual schema)是指将现实世界模型化的阶段进而&#xff0c;是确定数据库理论结构的阶段。 概念模式的设…
阅读更多...
PMSM 永磁同步电机滑膜控制 SVPWM矢量控制 matlab simulink 仿真

PMSM 永磁同步电机滑膜控制 SVPWM矢量控制 matlab simulink 仿真

仿真搭建平台&#xff1a; (1)该模型采用matlab/simulink 2016b版本搭建&#xff0c;使用matlab 2016b及以上版本打开最佳; (2)该模型已经提前转换了各个常用版本&#xff08;最低为matlab2012b&#xff09;&#xff0c;防止出现提示版本过高的情况。 模型截图&#xff1a; 算…
阅读更多...
基于springboot+vue的反欺诈平台的建设

基于springboot+vue的反欺诈平台的建设

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、阿里云专家博主、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战&#xff0c;欢迎高校老师\讲师\同行交流合作 ​主要内容&#xff1a;毕业设计(Javaweb项目|小程序|Pyt…
阅读更多...
律师如何看待项目管理中的技术风险

律师如何看待项目管理中的技术风险

大家好&#xff0c;我是不会魔法的兔子&#xff0c;是一枚北京的执业律师&#xff0c;创建[项目管理者的法小院儿]&#xff0c;持续从法律的角度分享项目管理中的风险问题及预防&#xff0c;让项目管理者能够提早发现与解决项目执行过程中的风险&#xff0c;同时欢迎大家一起交…
阅读更多...
Vue3 + Django 前后端分离项目实现密码认证登录

Vue3 + Django 前后端分离项目实现密码认证登录

1、功能需求 通常中小型前后端项目&#xff0c;对安全要求不高&#xff0c;也可以采用密码认证方案。如果只用django来实现非常简单。采用 Vue3 前后端分离架构&#xff0c;实现起来稍繁琐一点&#xff0c;好处是可以利用各种前端技术栈&#xff0c;如element-plus UI库来渲染…
阅读更多...
蓝桥杯 2022 省B 李白打酒加强版

蓝桥杯 2022 省B 李白打酒加强版

这题用递归暴力的方法如下&#xff1a; #include<iostream> #include<bits/stdc.h> using namespace std; int num; int N,M; void dfs(int now,int n,int m) {if(now<0 || n>N ||m>M)return ;if(nN && mM){if(now1)num1;return;}dfs(now-1,n,m1…
阅读更多...
DDR4总结最全纯干货分享

DDR4总结最全纯干货分享

DDR存储器发展的主要方向一言以蔽之&#xff0c;是更高速率&#xff0c;更低电压&#xff0c;更密的存储密度&#xff0c;从而实现更好的性能。 DDR4 SDRAM&#xff08;Double Data Rate Fourth SDRAM&#xff09;&#xff1a;DDR4提供比DDR3/ DDR2更低的供电电压1.2V以及更高的…
阅读更多...
如果搭建axb回拨

如果搭建axb回拨

AXB回拨技术是一种先进的电话通讯技术&#xff0c;它通过在A&#xff08;主叫方&#xff09;与B&#xff08;被叫方&#xff09;之间引入一个中间号码X&#xff0c;实现了双方的通话连接。这种技术可以有效避免直接拨打被叫方的电话号码&#xff0c;从而保护了用户的隐私。 具体…
阅读更多...
GPT2从放弃到入门(三)

GPT2从放弃到入门(三)

引言 上篇文章我们看到了如何从零训练一个聊天机器人&#xff0c;本文在此基础上介绍各种生成策略的原理和实现。最后通过Gradio构建一个聊天机器人应用。 定义生成框架 def generate(model,tokenizer,prompt,max_length255,temperature1.0,top_k50,top_p1.0,repetition_pen…
阅读更多...
【WEEK4】 【DAY4】AJAX第一部分【中文版】

【WEEK4】 【DAY4】AJAX第一部分【中文版】

【WEEK4】 【DAY4】AJAX第一部分【中文版】 2024.3.21 Thursday 目录 8.AJAX8.1.简介8.2.伪造ajax8.2.1.新建module&#xff1a;springmvc-06-ajax8.2.2.添加web支持&#xff0c;导入pom依赖8.2.2.1.修改web.xml8.2.2.2.新建jsp文件夹 8.2.3.新建applicationContext.xml8.2.4.…
阅读更多...
tftp使用

tftp使用

下载 sudo apt-get install tftpd-hpa 创建文件夹 mkdir /home/ljl/work/tftpd mkdir /home/ljl/tftpd chmod 777 tftpd/编辑 sudo vim /etc/default/tftpd-hpa //服务器端 sudo apt-get install tftp-hpa //客户端编辑权限 sudo vi /etc/default/tftpd-hpa 内容&#xff1…
阅读更多...
智能风扇的新篇章：唯创知音WTK6900G语音识别芯片引领行业革新

智能风扇的新篇章：唯创知音WTK6900G语音识别芯片引领行业革新

随着科技浪潮的推进&#xff0c;智能化技术逐渐渗透到生活的每一个角落&#xff0c;家电领域尤为明显。风扇&#xff0c;这一夏日清凉神器&#xff0c;也通过智能化改造&#xff0c;焕发出前所未有的光彩。其中&#xff0c;智能语音控制功能的加入&#xff0c;为风扇的使用带来…
阅读更多...
算法系列--递归(2)

算法系列--递归(2)

&#x1f495;"什么样的灵魂就要什么样的养料&#xff0c;越悲怆的时候我越想嬉皮。"&#x1f495; 作者&#xff1a;Mylvzi 文章主要内容&#xff1a;算法系列–递归(2) 前言:今天带来的是算法系列--递归(2)的讲解,包含六个和二叉树相关的题目哦 1.计算布尔⼆叉树的…
阅读更多...
Redis中文乱码问题

Redis中文乱码问题

最近排查问题&#xff0c;发现之前的开发将日志写在redis缓存中&#xff08;不建议这样做&#xff09;&#xff0c;我在查看日志的时候发现没办法阅读&#xff0c;详细是这样的&#xff1a; 查阅资料后发现是进制问题&#xff0c;解决方法是启动客户端的时候将redis-cli改为red…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023