C++简单实现红黑树

news2024/12/23 6:08:34

目录

一、概念

二、红黑树的性质

三、红黑树的定义

四、红黑树的插入操作

情况一（叔叔节点存在且为红色）——变色+向上调整：

情况二（叔叔节点不存在或为黑色）——旋转+变色：

2.1叔叔节点不存在

2.2叔叔节点为黑色

插入的代码实现：

五、红黑树的验证

六、红黑树完整代码

一、概念

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

二、红黑树的性质

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

三、红黑树的定义

enum Colour
{
	RED,BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_right(nullptr)
		,_left(nullptr)
		,_parent(nullptr)
		,_col(RED)//默认插入节点为红色，如果为黑色，就会对其他路径也造成影响
	{}

	pair<K, V> _kv;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _parent;
	
	Colour _col;
};

C++STL中的set和map底层就是使用红黑树实现的，而map是存放键值对的，所以我们给红黑树的节点中的值存放一个键值对，以及左右孩子的指针和指向父节点的指针，还有一个存放颜色的标记。

四、红黑树的插入操作

红黑树的插入首先和普通二叉搜索树的插入操作一样，新建一个节点，左节点的值小于根，右节点的值大于根，找到位置进行插入。插入后应如果破坏了红黑树的性质，就需要进行调整。

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何
性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连
在一起的红色节点，此时需要对红黑树分情况来讨论：

我们给出一个约定：cur为当前节点，p为父亲节点，g为祖父节点，u为叔叔节点

情况一（叔叔节点存在且为红色）——变色+向上调整：

将p和u改成黑色，将g改为红色

此时有三种情况：

1、g没有父亲节点，直接变成黑色就可以，插入结束；

2、g有父亲节点，且父亲为黑色，插入结束；

3、g有父亲节点，且父亲为红色（违反了红色节点不能连续的性质），需要向上调整。

情况二（叔叔节点不存在或为黑色）——旋转+变色：

2.1叔叔节点不存在

如果cur在parent的左边——右旋：

cur在parent的右边——先左旋再右旋：

2.2叔叔节点为黑色

如果cur在parent的左边——右旋：

cur在parent的右边——先左旋再右旋：

以上插入操作是p在g节点左边的情况，p在g节点右边的情况与以上插入过程类似，仅仅是镜像翻转一下。

插入的代码实现：

左旋代码：

void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		cur->_left = parent;
		if (curleft)
			curleft->_parent = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = cur;

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

右旋代码：

void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;

		parent->_left = curright;
		cur->_right = parent;

		if (curright)
			curright->_parent = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = cur;

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

插入代码：

    bool insert(const pair<K, V>& kv)
	{
		//如果root为空
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		//插入
		Node* cur = _root;
		Node* parent = cur;

		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);//插入节点

		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//插入完毕，开始调整颜色
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			//叔叔在右
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;

				//叔叔存在且为红色——变色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					//向上更新
					cur = grandfather;
					parent = cur->_parent;
				}
				//叔叔不存在或者为黑色——旋转+变色
				else
				{
					//右单旋即可
					if (parent->_left == cur)
					{
						RotateR(grandfather);
						//变色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//先左单旋，后右单旋
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						//变色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			//叔叔在左
			else
			{
				Node* uncle = grandfather->_left;
				//uncle存在且为红色——变色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					//向上更新
					cur = grandfather;
					parent = cur->_parent;
				}
				//uncle不存在或为黑色——旋转+变色
				else
				{
					//左单旋即可
					if (parent->_right == cur)
					{
						RotateL(grandfather);
						//变色
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					//先右单旋，再左单旋
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						//变色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}

		_root->_col = BLACK;

		return true;
	}

五、红黑树的验证

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

    bool checkcolour(Node* root, int benckmark, int blackcount)
	{
		if (root == nullptr)
		{
			if (blackcount != benckmark)
				return false;
			return true;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
			return false;
		if (root->_col == BLACK)
			++benckmark;
		return checkcolour(root->_left, benckmark, blackcount)
			&& checkcolour(root->_right, benckmark, blackcount);
	}

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

		if (root->_col != BLACK)
			return false;
		Node* cur = root;

        //求树中最左路径黑色节点的个数
		while (cur)
		{
			if (cur->_col == BLACK)
				++blackcount;
			cur = cur->_left;
		}
		return checkcolour(_root, 0, blackcount);
	}

六、红黑树完整代码

#pragma once

#include <iostream>
#include <vector>
using namespace std;

enum Colour
{
	RED,BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_right(nullptr)
		,_left(nullptr)
		,_parent(nullptr)
		,_col(RED)//默认插入节点为红色，如果为黑色，就会对其他路径也造成影响
	{}

	pair<K, V> _kv;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _parent;
	
	Colour _col;
};
/*
* 红黑树插入思路——关键在于uncle节点：
* 分为两大类：
* 一、如果uncle存在且为红色——仅仅变色即可
* 
*	       g(黑)                            g(红)     
*     p(红)     u(红)    ------->       p(黑)      u(黑) ------->继续向上更新
*  c(红)                            c(红)
* 
* 
* 二、如果uncle不存在或为黑色——旋转加变色
* 
* 情况一：       g(黑)                              p(红)
*            p(红)    NULL/黑  ------->       c(红)       g(黑)
*         c(红)
* 
*        仅仅右旋即可，g变成红色; p变成黑色;  break;
* 
* 情况二：       g(黑)                                  g(黑)                c(红)
*			 p(红)    NULL/黑  ------->   先左旋     c(红)    ------->   p(红)    g(黑) 
*               c(红)                             p(红)
* 
*        c变成黑色，g变成红色，break;
* 
* 情况三：情况一的对称图形
* 情况四：情况二的对称图形
* 
*/
template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	RBTree()
		:_root(nullptr)
	{}

	void InOrder()
	{
		cout << "InOrder: ";
		_InOrder(_root);
		cout << endl;
	}

	bool insert(const pair<K, V>& kv)
	{
		//如果root为空
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		//插入
		Node* cur = _root;
		Node* parent = cur;

		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);//插入节点

		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//插入完毕，开始调整颜色
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			//叔叔在右
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;

				//叔叔存在且为红色——变色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					//向上更新
					cur = grandfather;
					parent = cur->_parent;
				}
				//叔叔不存在或者为黑色——旋转+变色
				else
				{
					//右单旋即可
					if (parent->_left == cur)
					{
						RotateR(grandfather);
						//变色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//先左单旋，后右单旋
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						//变色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			//叔叔在左
			else
			{
				Node* uncle = grandfather->_left;
				//uncle存在且为红色——变色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					//向上更新
					cur = grandfather;
					parent = cur->_parent;
				}
				//uncle不存在或为黑色——旋转+变色
				else
				{
					//左单旋即可
					if (parent->_right == cur)
					{
						RotateL(grandfather);
						//变色
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					//先右单旋，再左单旋
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						//变色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}

		_root->_col = BLACK;

		return true;
	}

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

private:

	bool checkcolour(Node* root, int benckmark, int blackcount)
	{
		if (root == nullptr)
		{
			if (blackcount != benckmark)
				return false;
			return true;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
			return false;
		if (root->_col == BLACK)
			++benckmark;
		return checkcolour(root->_left, benckmark, blackcount)
			&& checkcolour(root->_right, benckmark, blackcount);
	}

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

		if (root->_col != BLACK)
			return false;
		Node* cur = root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++blackcount;
			cur = cur->_left;
		}
		return checkcolour(_root, 0, blackcount);
	}

	void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		cur->_left = parent;
		if (curleft)
			curleft->_parent = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = cur;

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

	void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;

		parent->_left = curright;
		cur->_right = parent;

		if (curright)
			curright->_parent = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = cur;

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

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}
private:
	Node* _root;
	int blackcount = 0;
};

测试：

运行结果：

之后更新红黑树的应用，用红黑树封装map和set。

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

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

相关文章

在 SDXL 上用 T2I-Adapter 实现高效可控的文生图

在 SDXL 上用 T2I-Adapter 实现高效可控的文生图

T2I-Adapter 是一种高效的即插即用模型&#xff0c;其能对冻结的预训练大型文生图模型提供额外引导。T2I-Adapter 将 T2I 模型中的内部知识与外部控制信号结合起来。我们可以根据不同的情况训练各种适配器&#xff0c;实现丰富的控制和编辑效果。 同期的 ControlNet 也有类似的…
阅读更多...
Windows Server 2012 R2 安装 .NET Framework 4.6.1

Windows Server 2012 R2 安装 .NET Framework 4.6.1

服务器操作系统是 Windows Server 2012 R2 版本&#xff0c;在安装 .NET Framework 4.6.1 过程中出现报错&#xff0c;报错截图如下&#xff1a; 通过上报报错可以发现是缺少对应的 KB2919355 更新&#xff0c;只有安装了此依赖才能在 Windows 8.1 或 Windows Server 2012 R2 …
阅读更多...
中秋海报设计技巧大公开

中秋海报设计技巧大公开

中秋节即将来临&#xff0c;为了帮助大家设计出完美的海报&#xff0c;本文将提供详细的步骤和技巧&#xff0c;让你轻松打造出令人满意的海报作品。 步骤一&#xff1a;注册并登录乔拓云后台&#xff0c;进入海报中心页面。 在制作海报之前&#xff0c;你需要先注册并登录乔拓…
阅读更多...
yolov5-6.0使用改进

yolov5-6.0使用改进

代码版本V6.0 源码 YOLOv5 v6.0 release 改动速览 推出了新的 P5 和 P6 ‘Nano’ 模型&#xff1a; YOLOV5n和YOLOV5n6。 Nano 将 YOLOv5s 的深度倍数保持为 0.33&#xff0c;但将 YOLOv5 的宽度倍数从 0.50 降低到 0.25&#xff0c;从而将参数从 7.5M 降低到 1.9M&#xff0…
阅读更多...
Linux shell 脚本中， $@ 和$# 分别是什么意思

Linux shell 脚本中， $@ 和$# 分别是什么意思

Linux shell 脚本中&#xff0c; 和 和 和# 分别是什么意思&#xff1f; $&#xff1a;表示所有脚本参数的内容 $#:表示返回所有脚本参数的个数。 示例&#xff1a;编写如下shell脚本&#xff0c;保存为test.sh #!/bin/sh echo “number:$#” echo “argume:$” 执行…
阅读更多...
李宏毅机器学习第一课（结尾附作业模型详细分析）

李宏毅机器学习第一课（结尾附作业模型详细分析）

机器学习就是让机器找一个函数f&#xff0c;这个函数f是通过计算机找出来的 如果参数少的话&#xff0c;我们可以使用暴搜&#xff0c;但是如果参数特别多的话&#xff0c;我们就要使用Gradient Descent Regression (输出的是一个scalar数值) Classification &#xff08;在…
阅读更多...
dart flutter json 转 model 常用库对比 json_serializable json_model JsonToDart

dart flutter json 转 model 常用库对比 json_serializable json_model JsonToDart

1.对比 我是一个初学者,一直跟着教材用原生的json,最近发现实在太麻烦了.所以搜索了一下,发现真的有很多现成的解决方案. 网页 https://app.quicktype.io/?ldart 这个是测试下来最好用的 有很多选项,可以使用 json_serializable 也可以不使用 json_serializable 这是推荐最…
阅读更多...
【模拟实现C语言库函数】atoi的模拟实现

【模拟实现C语言库函数】atoi的模拟实现

#include <stdio.h> #include <assert.h> #include <string.h> #include <math.h> int my_atoi(const char* str) {assert(str);size_t len strlen(str);size_t j len - 1;// 个位&#xff08;1234中的4&#xff09;int ret str[j--] - 0;// 十位百…
阅读更多...
基于PySide6的GUI程序开发全流程（看完就会）

基于PySide6的GUI程序开发全流程（看完就会）

本文详细记录了从零到一开发一个GUI程序的过程&#xff0c;想学PySide6的入门文章不二之选&#xff1b; 1 前言 1.1 开发框架的选择 GUI程序的开发方式太多了&#xff0c;这里肯定就是Python语言了&#xff0c;至于为什么&#xff0c;就不多描述了&#xff1b; 那么基于Pyth…
阅读更多...
YOLov5 分割数据集的制作（详细过程+代码）

YOLov5 分割数据集的制作（详细过程+代码）

1.labelme 的使用 每张图片会对应生成一个&#xff1a; 以上已经画好所有的数据集&#xff08;&#xff01;&#xff01;&#xff09; 2.这里介绍一下如果都是没有变化的数据集&#xff0c;标签的位置都一样&#xff0c;如何批量生成这个数据集 我们先将第一个数据集复制2275…
阅读更多...
红队打靶：THE PLANETS: MERCURY打靶思路详解（vulnhub）

红队打靶：THE PLANETS: MERCURY打靶思路详解（vulnhub）

目录 写在开头 第一步&#xff1a;主机发现和端口扫描 第二步&#xff1a;Web渗透 第三步&#xff1a;获取初步立足点并搜集信息 第四步&#xff1a;软连接劫持sudo提权 总结与思考 写在开头 本篇博客在自己的理解之上根据大佬红队笔记的视频进行打靶&#xff0c;详述了…
阅读更多...
C2. Powering the Hero (hard version)

C2. Powering the Hero (hard version)

题目&#xff1a;样例&#xff1a; 输入 5 5 3 3 3 0 0 6 0 3 3 0 0 3 7 1 2 3 0 4 5 0 7 1 2 5 0 4 3 0 5 3 1 0 0 4输出 6 6 8 9 4 思路&#xff1a; 贪心思维题&#xff0c;这道题要求的是一张一张的凑卡牌&#xff0c;凑到的是力量赋值卡就存储好&#xff0c;抽到 0 就是英…
阅读更多...
智能驾驶、智能家居、智能工业中的 AI 关键基础设施，半导体厂商恩智浦的角色是什么？

智能驾驶、智能家居、智能工业中的 AI 关键基础设施，半导体厂商恩智浦的角色是什么？

我们来看一条七年前的真实新闻报道&#xff0c;2016 年《福布斯》在报道中提到“2020 年会有 1000 万台的自动驾驶汽车”。然而 2023 年的现在&#xff0c;真正实现 L4 级别自动驾驶的汽车&#xff0c;仍然远远没有达到这个预测的数量。 另一边&#xff0c;数据显示&#xff0c…
阅读更多...
递归实例：汉诺塔问题（n个圆盘3个柱子abc 一次动一个盘子）

递归实例：汉诺塔问题（n个圆盘3个柱子abc 一次动一个盘子）

实例&#xff1a;汉诺塔问题 n个圆盘3个柱子abc 一次动一个盘子 把上面n-1个盘看成一个整体&#xff0c;下面1个盘看成一个整体 n-1盘经过c移动到b第n盘到cn-1盘经过a到c 1 3步就是小一规模的汉诺塔 移动次数递推式 h(x)2h(x-1)1 def hanoi(n, a, b, c):if n > 0:hano…
阅读更多...
Flutter笔记：AnimationMean、AnimationMax 和 AnimationMin 三个类的用法

Flutter笔记：AnimationMean、AnimationMax 和 AnimationMin 三个类的用法

Flutter笔记 AnimationMean、AnimationMax 和 AnimationMin三个类的用法 作者&#xff1a;李俊才 &#xff08;jcLee95&#xff09;&#xff1a;https://blog.csdn.net/qq_28550263 邮箱 &#xff1a;291148484163.com 本文地址&#xff1a;https://blog.csdn.net/qq_28550263/…
阅读更多...
第1篇 目标检测概述 —（3）YOLO系列算法

第1篇 目标检测概述 —（3）YOLO系列算法

前言&#xff1a;Hello大家好&#xff0c;我是小哥谈。YOLO&#xff08;You Only Look Once&#xff09;系列算法是一种目标检测算法&#xff0c;主要用于实时物体检测。相较于传统的目标检测算法&#xff0c;YOLO具有更快的检测速度和更高的准确率。YOLO系列算法的核心思想是将…
阅读更多...
织梦CMS采集插件-DEDE插件大全

织梦CMS采集插件-DEDE插件大全

在如今充满信息爆炸的互联网时代&#xff0c;维护一个具有吸引力和活力的网站或博客是一项具有挑战性的任务。对于那些使用织梦CMS建立网站的用户来说&#xff0c;如何持续不断地更新内容以吸引访问者成为了一个突出的问题。 什么是织梦CMS自动采集插件&#xff1f;这些插件是为…
阅读更多...
《雷达原理》课程笔记-第一章：绪论

《雷达原理》课程笔记-第一章：绪论

第一章 绪论
阅读更多...
【数据结构】【C++】哈希表的模拟实现(哈希桶)

【数据结构】【C++】哈希表的模拟实现(哈希桶)

【数据结构】&&【C】哈希表的模拟实现(哈希桶&#xff09; 一.哈希桶概念二.哈希桶模拟实现①.哈希结点的定义②.数据类型适配③.哈希表的插入④.哈希表的查找⑤.哈希表的删除⑥.哈希表的析构 三.完整代码 一.哈希桶概念 哈希桶这种形式的方法本质上是开散列法&#x…
阅读更多...
常用压缩解压缩命令

常用压缩解压缩命令

在Linux中常见的压缩格式有.zip、.rar、.tar.gz.、tar.bz2等压缩格式。不同的压缩格式需要用不同的压缩命令和工具。须知&#xff0c;在Linux系统中.tar.gz为标准格式的压缩和解压缩格式&#xff0c;因此本文也会着重讲解tar.gz格式压缩包的压缩和解压缩命令。须知&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023