DS-红黑树(RBTree)

一.红黑树

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]
如有错误，随时纠正，谢谢大家

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

极大提高工作效率的 Linux 命令

极大提高工作效率的 Linux 命令

作为一名软件开发人员&#xff0c;掌握 Linux 命令是必不可少的技能。即使你使用 Windows 或 macOS&#xff0c;你总会遇到需要使用 Linux 命令的场合。例如&#xff0c;大多数 Docker 镜像都基于 Linux 系统。要进行 DevOps 工作&#xff0c;你需要熟悉Linux&#xff0c;至少要…
阅读更多...
数据库被.[Goodmorningfriends@onionmail.org].faust勒索病毒加密，能恢复吗？

数据库被.[Goodmorningfriends@onionmail.org].faust勒索病毒加密，能恢复吗？

.faust勒索病毒有什么特点及危害&#xff1f; .faust勒索病毒是一种恶意软件&#xff0c;以其复杂的加密技术和勒索行为而闻名。这种病毒的主要目标是通过加密受害者的数据文件&#xff0c;然后勒索赎金以解密这些文件。它通常通过恶意附件、恶意链接或潜在的不安全下载源传播&…
阅读更多...
网络编程套接字——实现简单的TCP网络程序

网络编程套接字——实现简单的TCP网络程序

目录 1、TCP socket API详解 socket()&#xff1a; bind()&#xff1a; listen(): accept(): connect(): 2、简易的TCP网络程序 TcpServer.hpp TcpClient.cc Main.cc Log.hpp ThreadPool.hpp Task.hpp Init.hpp Daemon.hpp dict.txt Makefile 1、TCP socket A…
阅读更多...
第六十二回 宋江兵打大名城 关胜议取梁山泊-飞桨ONNX推理部署初探

第六十二回 宋江兵打大名城 关胜议取梁山泊-飞桨ONNX推理部署初探

石秀和卢俊义在城内走投无路&#xff0c;又被抓住。梁中书把他两个人押入死牢。蔡福把他俩关在一处&#xff0c;好酒好菜照顾着&#xff0c;没让两人吃苦。 第二天就接到城外梁山泊的帖子&#xff0c;说大军已经来到&#xff0c;要替天行道&#xff0c;让他放人&#xff0c;并…
阅读更多...
数据结构从入门到精通——快速排序

数据结构从入门到精通——快速排序

快速排序 前言一、快速排序的基本思想常见方式通用模块 二、快速排序的特性总结三、三种快速排序的动画展示四、hoare版本快速排序的代码展示普通版本优化版本为什么要优化快速排序代码三数取中法优化代码 五、挖坑法快速排序的代码展示六、前后指针快速排序的代码展示七、非递…
阅读更多...
【Netty】TCP粘包、拆包、编解码问题

【Netty】TCP粘包、拆包、编解码问题

TCP粘包、拆包、编解码问题 UserInfo userInfo1new UserInfo();ByteBuf buf Unpooled.copiedBuffer(userInfo1.toString().getBytes(StandardCharsets.UTF_8));UserInfo userInfo1new UserInfo(); 这行代码创建了一个新的UserInfo对象&#xff0c;并将其引用存储在名为userInf…
阅读更多...
力扣242. 有效的字母异位词

力扣242. 有效的字母异位词

思路&#xff1a;字母相互抵消的思路&#xff0c;本题字符串中只包含小写字母26位&#xff0c;那就新建record数组int[26]&#xff0c;下标0-25&#xff0c;代表小写字母a-z, 需要通过 某字符减a 来达到这一目的&#xff1b; class Solution {public boolean isAnagram(String…
阅读更多...
Tomcat 下载以及安装

Tomcat 下载以及安装

Tomcat安装及配置教程主要分为四步&#xff1a; 步骤一&#xff1a;首先确认自己是否已经安装JDK 1. cmd&#xff1a;查看java的版本 步骤二&#xff1a;下载安装Tomcat 1. 下载tomcat :Apache Tomcat - Welcome! 2. 选择对应的tomcat版本&#xff1a; 3. 进行安装&#…
阅读更多...
如何使用 Elasticsearch 作为向量数据库

如何使用 Elasticsearch 作为向量数据库

在今天的文章中&#xff0c;我们将很快地通过 Docker 来快速地设置 Elasticsearch 及 Kibana&#xff0c;并设置 Elasticsearch 为向量搜索。 拉取 Docker 镜像 docker pull docker.elastic.co/elasticsearch/elasticsearch:8.12.2 docker pull docker.elastic.co/kibana/kiba…
阅读更多...
Red Hat Enterprise Linux 9.2

Red Hat Enterprise Linux 9.2

Red Hat Enterprise Linux 9.2的安装 插入安装光盘&#xff0c;从光盘启动&#xff0c;选择 第一个选项&#xff0c;安装Red Hat Enterprise Linux 9.2 9.2支持简体中文 此次安装选择了英文安装&#xff0c;估计在生产环境大多也是选择的英文安装 安装选项此次也是选择的mi…
阅读更多...
利用MSF生成php，windows，Linux三类木马

利用MSF生成php，windows，Linux三类木马

一、什么是msfvenom&#xff1f; msfvenom是msf中的一个独立的负载生成器&#xff0c;它可以利用msf中的payloads和encoders来生成各种格式的木马文件&#xff0c;并在目标机上执行&#xff0c;配合meterpreter在本地监听上线。msfvenom是msfpayload和msfencode的结合体&#x…
阅读更多...
保姆级教学 - C语言 之 动态内存管理

保姆级教学 - C语言 之 动态内存管理

&#x1f308; 个人主页&#xff1a;白子寰 &#x1f525; 分类专栏&#xff1a;魔法指针&#xff0c;进阶C&#xff0c;C语言&#xff0c;C语言题集&#xff0c;C语言实现游戏&#x1f448; 希望得到您的订阅和支持~ &#x1f4a1; 坚持创作博文(平均质量分79.9)&#xff0c;分…
阅读更多...
shell常用通配符

shell常用通配符

目录 介绍 示例 * ? [a,b,...] / [ab...] [^a,b,...] / [^ab...] [x1-x2] {"xxx","xxx","xxx",...} {x1..x2} 介绍 示例 * 匹配0或多个字符 ls的-d选项可以只列出当前目录下的文件,而不会列出他们包含的内容: ? 只匹配任意一个字符 …
阅读更多...
MySQL基础（DDL,DML,DQL)

MySQL基础（DDL,DML,DQL)

目录 一DDL 1.1数据库操作 1.1.1查询所有数据库&#xff1a; 1.1.2创建数据库 1.1.3 使用数据库 1.1.4 删除数据库 1.2表操作 1.2.1表操作 1.2.1.1创建表 1.2.1.1.1约束 1.2.1.1.2 数据类型 1.2.1.1.2.1 数值类型 1.2.1.1.2.2 字符串类型 1.2.1.1.2.3日期类型 1.…
阅读更多...
Linux源码包安装

Linux源码包安装

目录 一、transmission源码包安装 二、 nginx源码包安装 一、transmission源码包安装 1、下载编译环境所需的软件包依赖 2、下载transmision源码包到用户主目录下 https://github.com/transmission/transmission/releases/download/4.0.5/transmission-4.0.5.tar.xz 3、解压…
阅读更多...
支持度和置信度

支持度和置信度

支持度和置信度是数据挖掘和关联规则挖掘领域中常用的两个指标&#xff0c;用于衡量项集之间的关联程度。 支持度&#xff08;Support&#xff09;&#xff1a;支持度是指某个项集在数据集中出现的频率&#xff0c;即该项集在数据集中出现的次数与总事务数之比。支持度用来衡量…
阅读更多...
Qt 利用共享内存实现一次只能启动一个程序(单实例运行)

Qt 利用共享内存实现一次只能启动一个程序(单实例运行)

Qt 利用共享内存实现一次只能启动一个程序 文章目录 Qt 利用共享内存实现一次只能启动一个程序摘要利用共享内存实现一次只能启动一个程序示例代码 关键字&#xff1a; Qt、 unique、 单一、 QSharedMemory、 共享内存 摘要 今天接着在公司搞我的屎山代码&#xff0c;按照…
阅读更多...
数学建模（层次分析法 python代码 案例）

数学建模（层次分析法 python代码 案例）

目录 介绍&#xff1a; 模板&#xff1a; 例题&#xff1a;从景色、花费、饮食&#xff0c;男女比例四个方面去选取目的地 准则重要性矩阵&#xff1a; 每个准则的方案矩阵&#xff1a;​ 一致性检验&#xff1a; 特征值法求权值&#xff1a; 完整代码&#xff1a; 运行结…
阅读更多...
基于ssm新生报到系统论文

基于ssm新生报到系统论文

摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对新生报到信息管理混乱&#xff0c;出错率高&#xff0c;信息安全性差…
阅读更多...
containerd源代码分析: 整体架构

containerd源代码分析: 整体架构

本文从代码的大的整体组织上来熟悉containerd项目 containerd项目总的说是一个cs模式的原生控制台程序组。containerd作为服务端来接收处理client的各种请求&#xff0c;如常用的拉取推送镜像&#xff0c;创建查询停止容器&#xff0c;生成快照&#xff0c;发送消息等。client/…
阅读更多...
最新文章

Copyright @ 2022~2023