数据结构：红黑树的插入实现(C++)

news2024/9/25 11:17:19

在这里插入图片描述

个人主页 ： 个人主页
个人专栏 ： 《数据结构》 《C语言》《C++》《Linux》

文章目录

  • 一、红黑树
  • 二、红黑树的插入
  • 三、代码实现
  • 总结

一、红黑树

红黑树的概念：
红黑树是一颗二叉搜索树，但在每个节点上增加一个存储位表示节点的颜色，该节点颜色不是红色就是黑色。通过对每一条从根节点到叶子结点路径上各个节点颜色的控制，确保没有一条路径会比其它路径长出两倍，因此红黑树是接近平衡。

在这里插入图片描述

那红黑树是通过哪些规则来对节点颜色进行控制？

  1. 每个节点不是红色就是黑色

  2. 根节点是黑色

  3. 如果一个节点是红色，则其两个子节点是黑色(不能有连续的红色节点)

  4. 对于每个节点，从该节点到其所以叶子结点的路径上，其黑色节点的数目相同

  5. 每个叶子结点都是黑色的(此处的叶子结点是空节点(NIL)，方便我们计算路径的个数)
    注意：上述中的路径是从某一节点到NIL节点。如上图8节点到叶子结点就有5条路径，每条路径都有一个黑色节点。

那为什么遵循这5条规则，红黑树就能保证其最长路径中节点的个数不会超过最短路径节点个数的两倍？
我们假设从根节点到叶子结点的黑色节点数为n，那么最短路径不就是连续的黑色节点，最短路径的节点数为n，那么最长路径不就是红黑相间，最长路径的节点数为2n。所以红黑树保证其最长路径中节点的个数不会超过最短路径节点个数的两倍。

下面是红黑树节点的定义。

enum
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode(T data = T())
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(data)
		,_col(RED)
	{}

	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	T _data;
	int _col;
};

该定义中，我们默认将新节点颜色定义为红色，这样我们插入节点时需要维护规则的成本就少。如我们新插入一个红色节点，那么有可能会违背规则3(当其父节点是红色时，有连续红色节点)，这时我们可能需要一些变色和旋转，来维持规则，但如果我们插入节点是黑色，那么我们一定违背4(每条路径上黑色节点数相同)，这时我们可能需要对整个数进行操作。

二、红黑树的插入

红黑树也是一个二叉搜索树，插入新节点与二叉搜索树的操作一样，如果新插入节点比该节点大，新插入节点就去该节点的右子树，反之去该节点的左子树。

if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur != nullptr)
		{
			parent = cur;
			if (cur->_data > data)
			{
				cur = cur->_left;
			}
			else if(cur->_data < data)
			{
				cur = cur->_right;
			}
			else // cur->_data == data
			{
				return false;
			}
		}
		
		cur = new Node(data);
		cur->_parent = parent;
		if (cur->_data > parent->_data)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

这里我们主要分析新插入节点后，红黑树的情况和处理。对于旋转，这里并不会详细解析。对于旋转的详细解析在我的AVL树一文中。数据结构：AVLTree的插入和删除的实现

在分析情况前，我们先了解几个节点的含义，方便后续的理解。
在这里插入图片描述
接下来的所有情况都与这四个节点有关。

因为我们新插入的节点是红色，如果新插入节点的父节点是黑色，那么红黑树的规则未被破坏。如果新插入节点的父节点是红色，那么就有连续的红色节点。这是我们就要分情况讨论。

情况1. cur为红色，parent为红色，grandfather为黑色，uncle为红色
也就是如下图所示：
在这里插入图片描述
这种情况是最简单的情况，我们只需要将parent 与 uncle的颜色变成黑色(解决连续红色节点)，再将grandfather的颜色变成红色(防止经过grandfather路径的黑色节点数+1)
在这里插入图片描述
但就如上图所示，因为我们将grandfather的颜色变成红色，如果grandfather的父节点的颜色也是红色，这时我们依旧有连续的红色节点，我们仍需对grandfather进行处理。
在这里插入图片描述
我们重复变色过程
在这里插入图片描述
这时，grandfather没有父节点，就可以停止了，但此时grandfather作为根节点为红色，我们需要特殊处理一下即可。这样对于该插入新节点的情况一就完成了。
下面是总结的模型：
在这里插入图片描述
对于这种cur，parent，uncle为红色，grandfather为黑色的情况，我们只需让parent，uncle变成红色，grandfather变成黑色，接着需要检查grandfather的父节点是否是红色，如果是红色，重复上述操作。如果是黑色，就可以结束了。

情况2：cur为红色，parent为红色，grandfather为黑色，uncle不存在或uncle存在且为黑色
在这里插入图片描述
这时情况1 的处理就行不通了，因为uncle要么不存在，要么本身就为黑色，如果将grandfather变成红色，那么经过grandfather的路径的黑色节点数就-1。所以我们要采取旋转+变色。
在这里插入图片描述
因为cur在parent的右侧，parent在grandfather的右侧，成直线。所以我们对grandfather左单旋，接着将parent的颜色变成黑色，grandfather的颜色变成红色(防止经过grandfather的路径的黑色节点数+1)，又因为parent作为新的根节点为黑色，所以我们不需要去检查parent的父节点的颜色。(虽然我们也可以只将cur变为黑色，但这样我们就需要检查parent父节点的颜色)
那如果我们新增5节点要怎么处理？
在这里插入图片描述
此时我们也需要旋转+变色，但我们要双旋。
在这里插入图片描述
如上图，我们要先对parent左单旋，使grandfather，cur，parent在同一侧，接着使grandfather左单旋，cur变为黑色，grandfather变成红色。
如果parent在grandfather的左侧，情况与上述情况类似，只需要改变旋转方向即可。
下面是总结的模型：
单旋在这里插入图片描述
双旋
在这里插入图片描述

while (parent != nullptr && parent->_col != BLACK)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				if (uncle != nullptr && uncle->_col == RED) // uncle存在且为红色
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else if (uncle == nullptr || uncle->_col == BLACK) // uncle不存在 或 umcle存在且为黑
				{
					if (cur == parent->_left) // 同方向
					{
						RotateR(grandfather);

						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else // cur == parent->_right 不同方向
					{
						RotateL(parent);
						RotateR(grandfather);
						
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else // parent == grandfather->_right
			{
				Node* uncle = grandfather->_left;
				if (uncle != nullptr && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else if (uncle == nullptr || uncle->_col == BLACK)
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}

			}
		}

		_root->_col = BLACK; //特殊处理，保证根节点是黑色

则此，红黑树的插入就完成了。

三、代码实现

RBTree.h 文件是红黑树插入的实现
test.cpp 文件是测试用例

// RBTree.h 文件
#pragma once

enum
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode(T data = T())
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(data)
		,_col(RED)
	{}

	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	T _data;
	int _col;
};

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

	bool insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur != nullptr)
		{
			parent = cur;
			if (cur->_data > data)
			{
				cur = cur->_left;
			}
			else if(cur->_data < data)
			{
				cur = cur->_right;
			}
			else // cur->_data == data
			{
				return false;
			}
		}
		
		cur = new Node(data);
		cur->_parent = parent;
		if (cur->_data > parent->_data)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		while (parent != nullptr && parent->_col != BLACK)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				if (uncle != nullptr && uncle->_col == RED) // uncle存在且为红色
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else if (uncle == nullptr || uncle->_col == BLACK) // uncle不存在 或 umcle存在且为黑
				{
					if (cur == parent->_left) // 同方向
					{
						RotateR(grandfather);

						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else // cur == parent->_right 不同方向
					{
						RotateL(parent);
						RotateR(grandfather);
						
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else // parent == grandfather->_right
			{
				Node* uncle = grandfather->_left;
				if (uncle != nullptr && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else if (uncle == nullptr || uncle->_col == BLACK)
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}

			}
		}

		_root->_col = BLACK;
		return true;
	}

	// 读取红黑树最左侧节点
	Node* leftMost()
	{
		if (_root == nullptr)
		{
			return nullptr;
		}
		Node* cur = _root;
		while (cur->_left != nullptr)
		{
			cur = cur->_left;
		}
		return cur;
	}

	// 读取红黑树最右侧节点
	Node* rightMost()
	{
		if (_root == nullptr)
		{
			return nullptr;
		}
		Node* cur = _root;
		while (cur->_right != nullptr)
		{
			cur = cur->_right;
		}
		return cur;
	}

	bool isValidRBTree()
	{
		if (_root->_col == RED)
		{
			return false;
		}

		// 找最左边的黑色节点数作为标准比较
		int pathBlack = 0;
		Node* cur = _root;
		while (cur != nullptr)
		{
			if (cur->_col == BLACK)
			{
				pathBlack++;
			}

			cur = cur->_left;
		}

		return _isValidRBTree(_root, 0, pathBlack);
	}

	bool _isValidRBTree(Node* root, int blackCount, int pathBlack)
	{
		if (root == nullptr)
		{
			if (blackCount == pathBlack)
				return true;
			else
				return false;
		}

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

		if (root->_col == BLACK)
		{
			blackCount++;
		}
		return _isValidRBTree(root->_left, blackCount, pathBlack)
			&& _isValidRBTree(root->_right, blackCount, pathBlack);
	}


	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* pparent = parent->_parent;

		parent->_left = subLR;
		subL->_right = parent;

		parent->_parent = subL;
		if (subLR != nullptr)
		{
			subLR->_parent = parent;
		}
		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;
		Node* pparent = parent->_parent;

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

private:
	Node* _root;
};


//test.cpp 文件
#include <iostream>
#include <vector>

using namespace std;
#include "RBTree.h"

#define N 10000000

void test1()
{
	vector<int> nums(N);
	srand((unsigned int)time(0));

	for (int i = 0; i < N; i++)
	{
		nums[i] = rand() + i;
		//cout << nums[i] << endl;
	}

	RBTree<int> tree;
	for (auto val : nums)
	{
		if (val == 11478)
		{
			int i = 0;
			i++;
		}
		tree.insert(val);
		//cout << val << "->" << tree.isValidRBTree() << endl;
	}
	cout << tree.isValidRBTree() << endl;
}

int main()
{
	test1();

	return 0;
}

总结

以上就是我对于红黑树插入实现的总结。感谢支持！！！
在这里插入图片描述

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

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

相关文章

Android图片涂鸦，Kotlin（1）

Android图片涂鸦，Kotlin（1）

Android图片涂鸦&#xff0c;Kotlin&#xff08;1&#xff09; import android.content.Context import android.graphics.Canvas import android.graphics.Color import android.graphics.Paint import android.graphics.Path import android.graphics.PointF import android.…
阅读更多...
改进YOLOv8：结合ODConv构成C2f_ODConv：即插即用的动态卷积/可轻量化

改进YOLOv8：结合ODConv构成C2f_ODConv：即插即用的动态卷积/可轻量化

🗝️YOLOv8实战宝典--星级指南：从入门到精通，您不可错过的技巧   -- 聚焦于YOLO的 最新版本， 对颈部网络改进、添加局部注意力、增加检测头部，实测涨点 💡 深入浅出YOLOv8：我的专业笔记与技术总结   -- YOLOv8轻松上手， 适用技术小白，文章代码齐全，仅需 …
阅读更多...
常见树种（贵州省）：003柏类

常见树种（贵州省）：003柏类

摘要&#xff1a;本专栏树种介绍图片来源于PPBC中国植物图像库&#xff08;下附网址&#xff09;&#xff0c;本文整理仅做交流学习使用&#xff0c;同时便于查找&#xff0c;如有侵权请联系删除。 图片网址&#xff1a;PPBC中国植物图像库——最大的植物分类图片库 一、柏木 …
阅读更多...
创新案例｜云服务平台HashiCorp是如何构建开源社区实现B2B增长飞轮

创新案例｜云服务平台HashiCorp是如何构建开源社区实现B2B增长飞轮

社区文化是HashiCorp企业文化的重要组成部分。虽然众多公司声称自己是社区驱动&#xff0c;但实际付诸行动的很少。与众不同的是&#xff0c;HashiCorp从一开始就将社区视为战略方针的核心&#xff0c;这也影响和塑造了公司今天的发展方向。社区不仅是执行策略之一&#xff0c;…
阅读更多...
卷积神经网络（CNN）天气识别

卷积神经网络（CNN）天气识别

文章目录 前期工作1. 设置GPU&#xff08;如果使用的是CPU可以忽略这步&#xff09;我的环境&#xff1a; 2. 导入数据3. 查看数据 二、数据预处理1. 加载数据2. 可视化数据3. 再次检查数据4. 配置数据集 三、构建CNN网络四、编译五、训练模型六、模型评估 前期工作 1. 设置GP…
阅读更多...
SDUT OJ《算法分析与设计》贪心算法

SDUT OJ《算法分析与设计》贪心算法

A - 汽车加油问题 Description 一辆汽车加满油后可行驶n公里。旅途中有若干个加油站。设计一个有效算法&#xff0c;指出应在哪些加油站停靠加油&#xff0c;使沿途加油次数最少。并证明算法能产生一个最优解。 对于给定的n和k个加油站位置&#xff0c;计算最少加油次数。 I…
阅读更多...
uniapp 微信小程序登录 新手专用 引入即可

uniapp 微信小程序登录 新手专用 引入即可

预览 第一步导入插件 在引入的页面的登录按钮下拷贝一下代码 <template><view class"content"><button type"primary" click"login">微信登录</button></view><TC-WXlogin :wxloginwxlogin /> </templ…
阅读更多...
【Java 进阶篇】Ajax 入门：打开前端异步交互的大门

【Java 进阶篇】Ajax 入门：打开前端异步交互的大门

欢迎来到前端异步交互的世界&#xff01;在这篇博客中&#xff0c;我们将深入探讨 Ajax&#xff08;Asynchronous JavaScript and XML&#xff09;&#xff0c;这是一项能够让你的网页在不刷新的情况下与服务器进行数据交互的技术。无论你是刚刚踏入前端开发的小白&#xff0c;…
阅读更多...
python-opencv 培训课程作业

python-opencv 培训课程作业

python-opencv 培训课程作业 作业一&#xff1a; 第一步&#xff1a;读取 res 下面的 flower.jpg&#xff0c;读取彩图&#xff0c;并用 opencv 展示 第二步&#xff1a;彩图 -> 灰度图 第三步&#xff1a;反转图像&#xff1a;最大图像灰度值减去原图像&#xff0c;即可得…
阅读更多...
C语言——2.安装并使用VS

C语言——2.安装并使用VS

文章目录 1.编译器是什么2.编译器的选择2.1.VS2019/2022 的初步了解2.2.为什么不选择其他编译器呢&#xff1f; 3.编译器的安装过程&#xff08;保姆级别教学&#xff09;3.1.检查电脑版本3.2.下载安装包3.3.选择安装选项3.4.重启电脑3.5.创建账户登录3.6.颜色配置3.7.VS&#…
阅读更多...
「Verilog学习笔记」根据状态转移图实现时序电路

「Verilog学习笔记」根据状态转移图实现时序电路

专栏前言 本专栏的内容主要是记录本人学习Verilog过程中的一些知识点&#xff0c;刷题网站用的是牛客网 这是一个典型的米利型状态机。三段式即可解决。 米利型状态机&#xff1a;即输出不仅和当前状态有关&#xff0c;也和输入有关。 其中ST0&#xff0c;ST1&#xff0c;ST3的…
阅读更多...
力扣刷题篇之位运算

力扣刷题篇之位运算

系列文章目录 目录 系列文章目录 前言 一、位运算的基本运算 二、位运算的技巧 三、布隆过滤器 总结 前言 本系列是个人力扣刷题汇总&#xff0c;本文是数与位。刷题顺序按照[力扣刷题攻略] Re&#xff1a;从零开始的力扣刷题生活 - 力扣&#xff08;LeetCode&#xff0…
阅读更多...
大反转！OpenAI董事会辞职，求奥特曼重返OpenAI？「奥特曼24小时流放」大揭秘...

大反转！OpenAI董事会辞职，求奥特曼重返OpenAI？「奥特曼24小时流放」大揭秘...

大家好&#xff0c;我是二狗。 想必大家昨天都被Sam Altman被董事会解雇的事情刷屏了。 然而才仅仅过去一天&#xff0c;OpenAI 董事会就反悔了&#xff01;正和Sam Altman 商量让他重返CEO职位。 这一反转和Altman被炒鱿鱼一样突然&#xff0c;凄凄惨惨真真假假真真&#x…
阅读更多...
SpirngBoot + Vue 前后端分离开发工具代码

SpirngBoot + Vue 前后端分离开发工具代码

✅作者简介&#xff1a;大家好&#xff0c;我是Leo&#xff0c;热爱Java后端开发者&#xff0c;一个想要与大家共同进步的男人&#x1f609;&#x1f609; &#x1f34e;个人主页&#xff1a;Leo的博客 &#x1f49e;当前专栏&#xff1a; Java从入门到精通 ✨特色专栏&#xf…
阅读更多...
SQL练习02

SQL练习02

1.买下所有产品的客户 SQL Create table If Not Exists Customer (customer_id int, product_key int); Create table Product (product_key int); Truncate table Customer; insert into Customer (customer_id, product_key) values (1, 5); insert into Customer (customer_…
阅读更多...
丢掉破解版，官方免费了！！！

丢掉破解版，官方免费了！！！

哈喽&#xff01;大家好。 几天不见&#xff0c;今天给大家带来一款海外的神器&#xff0c;官方宣布完全免费&#xff0c;但仅限于个人与教育用途&#xff0c;切勿商用噢&#xff01; 不要看这个软件名字普普通通&#xff0c;实际上内蕴乾坤&#xff01; 接下来看我给大家炫一…
阅读更多...
Loguru：一个超酷的Python库

Loguru：一个超酷的Python库

在项目中&#xff0c;了解代码运行情况至关重要&#xff0c;特别是遇到Bug需要排除问题的时候&#xff0c;而这正是日志记录发挥作用的地方。对于Python开发者来说&#xff0c;Loguru是一个简单但功能强大的日志记录库&#xff0c;它使得跟踪代码的行为变得轻松而高效。 什么是…
阅读更多...
穿越风波，“长红”的直播电商依然扎根产业和消费者

穿越风波，“长红”的直播电商依然扎根产业和消费者

当消费者将最后一个快递拿进家门&#xff0c;2023年的双11也就落下了帷幕。相较于往年组队、拼单的玩法&#xff0c;如今最受欢迎的双11 流程&#xff0c;或许已经变成点进自己心仪主播、店铺的直播间&#xff0c;翻阅最新的产品清单&#xff0c;从中选择购物目标&#xff0c;在…
阅读更多...
文件钓鱼-后缀隐藏文件捆绑文件压缩释放技巧

文件钓鱼-后缀隐藏文件捆绑文件压缩释放技巧

0x00 文件钓鱼 简单说下文件样本钓鱼的目的&#xff0c;为诱导用户安装木马文件&#xff0c;达到控制或者窃取某些信息的目的&#xff0c;抛开邮件的真实性。木马的伪造是一个比较关键的点&#xff0c;下面简要说下三种木马文件伪装的技巧 0x01 水坑攻击与鱼叉攻击的概念 水坑…
阅读更多...
Visual Studio Code 从英文界面切换中文

Visual Studio Code 从英文界面切换中文

1、先安装中文的插件&#xff0c;直接安装。 2、点击右下角的 change language restart&#xff0c; 让软件重启即可以完成了。
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023