红黑树简析

最新推荐文章于 2024-05-04 22:59:00 发布
最新推荐文章于 2024-05-04 22:59:00 发布
阅读量4.2k 收藏 22
点赞数 25
分类专栏： 数据结构 文章标签： 算法 数据结构 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/finish_speech/article/details/128929840
版权

一.   概念

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

 二.   性质

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

2. 根节点是黑色的

3. 如果一个节点是红色的，则它的两个孩子结点是黑色的

4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点

5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

由于从一个节点起的每条路径中的黑色节点数目相同，因此最短为全黑，同时由于红节点不连续，因此最长为一半红一半黑，因此不会超出两倍

三.   节点定义

三叉链，key-value模型、额外的标明颜色的变量（颜色可以使用枚举常量）

同时，为了在插入时遵循第4条准则，我们将颜色变量的默认值设为红色

enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _kv;

	Colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
		, _kv(kv)
	{}
};

四.   基本框架

template<class K, class V>
struct RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	RBTree()
		:_root(nullptr)
	{}
private:
		Node* _root;
};

五.   插入

首先，一开始与AVL树是一致的，都是通过比较key来寻找合适的位置进行插入

bool Insert(const pair<K, V>& kv)
{
	if (!_root)
	{
		_root = new Node(kv);
		_root->_col = BLACK;
		return false;
	}
	Node* parent = nullptr;
	Node* cur = _root;

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

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

之后，虽然我们插入红色节点会使得每条路径的黑节点数目相同，但还要注意在红节点连续时进行相应的调整

在调整时，依旧是从插入节点（cur）向上迭代来观察，而我们需要进行调整的情况为cur和parent的颜色都为红，主要分为这两种情况

同样，和AVL树一样，也有对称的情况，但操作方法也都是类似的，不多说了

而这两种情况，我们对子树4的情况进行细分，首先当节点1的右节点为红色时

 处理方法都是一样的，只需要将节点2、4的颜色改为黑色，同时，我们在改变结构时，为了减小对上面的影响，应该保证前后的路径中黑节点的数目相同，改色之前，黑节点数目为n+1，因此，我们还需要将节点1改为红色

而由于我们将节点1的颜色改为了红色，我们需要继续向上判断

while (parent&&parent->_col == RED)
{
	Node* par_parent = parent->_parent;
	Node* uncle = nullptr;
	if (parent == par_parent->_left)
		uncle = par_parent->_right;
	else
		uncle = par_parent->_left;

	if (uncle && uncle->_col == RED)
	{
		uncle->_col = BLACK;
		parent->_col = BLACK;
		par_parent->_col = RED;
		cur = par_parent;
		parent = cur->_parent;
	}
}

 

还有两种情况，是节点4不存在或节点4为黑色，这两种情况的处理情况相同，由于不需要对节点4进行处理，我们就简化一下

首先是情况1

 首先若是我们想要改变颜色，首先对于节点2，右侧路径黑节点为n个，因此左侧也应该为n个，所以节点3的颜色不能改变，因此我们只能改变节点2，这样对于节点1，两侧路径的黑节点数目就不可能相同了，因此，我们可以使用在AVL树中使用到的旋转，很容易看出，我们需要使用右旋（对称情况使用左旋）

 之后，便可以来改变颜色，首先，有两种方案，节点3改为黑色或节点1改为红色、节点2改为黑色，原本路径中黑节点数为n+1，这两种方案改变后都符合，但由于若是我们将节点2颜色改为黑色，与改变前类似，也就不需要继续向上判断了，因此采用第二种方法

else
{
	if (cur == parent->_left && parent == par_parent->_left)
	{
		RotateR(par_parent);
		parent->_col = BLACK;
		par_parent->_col = RED;
	}
	else if (cur == parent->_right && parent == par_parent->_right)
	{
		RotateL(par_parent);
		parent->_col = BLACK;
		par_parent->_col = RED;
	}
	break;
}

而左旋和右旋和AVL树是一样的 

void RotateL(Node* parent)
{
	Node* par_parent = parent->_parent;
	Node* right = parent->_right;
	Node* right_left = right->_left;
	if (par_parent)
	{
		if (parent == par_parent->_left)
			par_parent->_left = right;
		else
			par_parent->_right = right;
	}
	else
	{
		_root = right;
	}
	right->_parent = par_parent;
	if (right_left)
		right_left->_parent = parent;
	parent->_right = right_left;
	right->_left = parent;
	parent->_parent = right;
}

void RotateR(Node* parent)
{
	Node* par_parent = parent->_parent;
	Node* left = parent->_left;
	Node* left_right = left->_right;
	if (par_parent)
	{
		if (parent == par_parent->_left)
			par_parent->_left = left;
		else
			par_parent->_right = left;
	}
	else
	{
		_root = left;
	}
	left->_parent = par_parent;
	if (left_right)
		left_right->_parent = parent;
	parent->_left = left_right;
	left->_right = parent;
	parent->_parent = left;
}

 

之后便是情况2

同样只是改变颜色无法实现平衡 

我们就需要进行双旋

之后就需要改变颜色

还是将节点3变黑，节点1变红，不需要向上调整

else
{
	if (cur == parent->_left && parent == par_parent->_left)
	{
		RotateR(par_parent);
		parent->_col = BLACK;
		par_parent->_col = RED;
	}
	else if (cur == parent->_left && parent == par_parent->_right)
	{
		RotateR(parent);
		RotateL(par_parent);
		cur->_col = BLACK;
		par_parent->_col = RED;
	}
	else if (cur == parent->_right && parent == par_parent->_right)
	{
		RotateL(par_parent);
		parent->_col = BLACK;
		par_parent->_col = RED;
	}
	else
	{
		RotateL(parent);
		RotateR(par_parent);
		cur->_col = BLACK;
		par_parent->_col = RED;
	}
	break;
}

而在最后，头结点可能会被我们改变为红色，我们只需要将其手动变为黑就好了，不会对下面产生影响

总览

bool Insert(const pair<K, V>& kv)
{
	if (!_root)
	{
		_root = new Node(kv);
		_root->_col = BLACK;
		return false;
	}
	Node* parent = nullptr;
	Node* cur = _root;

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

	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* par_parent = parent->_parent;
		Node* uncle = nullptr;
		if (parent == par_parent->_left)
			uncle = par_parent->_right;
		else
			uncle = par_parent->_left;

		if (uncle && uncle->_col == RED)
		{
			uncle->_col = BLACK;
			parent->_col = BLACK;
			par_parent->_col = RED;
			cur = par_parent;
			parent = cur->_parent;
		}
		else
		{
			if (cur == parent->_left && parent == par_parent->_left)
			{
				RotateR(par_parent);
				parent->_col = BLACK;
				par_parent->_col = RED;
			}
			else if (cur == parent->_left && parent == par_parent->_right)
			{
				RotateR(parent);
				RotateL(par_parent);
				cur->_col = BLACK;
				par_parent->_col = RED;
			}
			else if (cur == parent->_right && parent == par_parent->_right)
			{
				RotateL(par_parent);
				parent->_col = BLACK;
				par_parent->_col = RED;
			}
			else
			{
				RotateL(parent);
				RotateR(par_parent);
				cur->_col = BLACK;
				par_parent->_col = RED;
			}
			break;
		}
	}
	_root->_col = BLACK;
	return true;
}

void RotateL(Node* parent)
{
	Node* par_parent = parent->_parent;
	Node* right = parent->_right;
	Node* right_left = right->_left;
	if (par_parent)
	{
		if (parent == par_parent->_left)
			par_parent->_left = right;
		else
			par_parent->_right = right;
	}
	else
	{
		_root = right;
	}
	right->_parent = par_parent;
	if (right_left)
		right_left->_parent = parent;
	parent->_right = right_left;
	right->_left = parent;
	parent->_parent = right;
}

void RotateR(Node* parent)
{
	Node* par_parent = parent->_parent;
	Node* left = parent->_left;
	Node* left_right = left->_right;
	if (par_parent)
	{
		if (parent == par_parent->_left)
			par_parent->_left = left;
		else
			par_parent->_right = left;
	}
	else
	{
		_root = left;
	}
	left->_parent = par_parent;
	if (left_right)
		left_right->_parent = parent;
	parent->_left = left_right;
	left->_right = parent;
	parent->_parent = left;
}

六.   验证 

首先就是验证是否为搜索树，和AVL树的一致

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

void _InOrder(Node* root)
{
	if (root == NULL)
		return;

	_InOrder(root->_left);
	cout << root->_kv.first << ":" << root->_kv.second <<':' << root->_col << "  ";
	_InOrder(root->_right);
}

之后，还需要验证三个问题：根节点是否为黑，路径中的黑节点数目是否相同、红节点是否不连续

首先第一点很好验证，若是验证第二点，我们可以先得到一条路径的黑节点，之后以它为基准，对每条路径进行判断，最后在遍历路径的时候顺便对红节点是否连续做一下判断

bool IsBalance()
{
	if (_root && _root->_col == RED)
	{
		cout << "根节点不是黑色" << endl;
		return false;
	}

	int banchmark = 0;
	Node* left = _root;
	while (left)
	{
		if (left->_col == BLACK)
			banchmark++;
		left = left->_left;
	}
	int blackNum = 0;
	return _IsBalance(_root, banchmark, blackNum);
}

bool _IsBalance(Node* root, int& banchmark, int blackNum)
{
	if (!root)
	{
		if (banchmark != blackNum)
		{
			cout << "存在路径黑色节点的数量不相等" << endl;
			return false;
		}
		return true;
	}
	if (root->_col == RED && root->_parent->_col == RED)
	{
		cout << "出现连续红色节点" << endl;
		return false;
	}

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

	return _IsBalance(root->_left, banchmark, blackNum)
		&& _IsBalance(root->_right, banchmark, blackNum);
}

end


 


 

finish_speech
关注
专栏目录
通俗易懂的红黑树简析
LiQiyao的博客
01-31 794
一、基本概念  红黑树本质上是一棵近似平衡的二叉树，它的节点只有两种颜色即红与黑，它满足二叉搜索树的基本性质，即树上的任何节点的值大于其左子节点（若左子节点存在），任何节点的值大于其右子节点的值（若右子节点存在）。  近似平衡：深度最大的节点的深度  红黑树与平衡二叉树比较：因为红黑树只追求近似平衡，所以在插入与删除节点时，翻转次数远远少于平衡树，因此在需要较多插入删除操作的
红黑树添加1111111
09-29
红黑树添加
快速理解红黑树原理
热门推荐
jjc120074203的博客
01-31 2万+
红黑树 红黑树 其实就是一个二叉树。 常用的二叉树类型 简单说二叉树概念： 二叉树 又称度为至多二的树。 平衡二叉树 平衡二叉树又称 AVL 树 特点：一个根节点的左右个子树的高度差不超过1 平衡二叉树 非平衡二叉树 高度差已经大于1 了。 平衡树解决的问题就是 能够最大限度的增加访问的每个节点的的平均性 。保证每个节点被访问的次数平衡。 完全二叉树
算法与数据结构--红黑树简析
云逸 Dean的专栏
08-30 822
1.为什么要使用红黑树： 可以保证在 O（logN）的时间复杂度下做查找 删除 添加 2.性质： （来自于维基百科Red–black tree条目 ） 节点是红色或者黑色的（Each node is either red or black） 根是黑色的,有时会被省略，由于根是黑色和红色对规范并没有其他影响(The root is black. This rule is sometimes...
红黑树的简析
weixin_47352169的博客
08-22 117
红黑树其实算是一种特殊的二叉查找树，二叉正常的时候时间复杂度为O（logN），但是当它出现链表情况的时候，会不一样，查询链表数据时间复杂度会变为O（N）； 红黑树通过几个特性，基本规避了二叉查找树出现链表的情况，也就是说，红黑树就是不会出现链表的二叉查找树。 红黑色的特性，必须满足： 根节点必须是黑色，无父节点； 红色节点不可以连到一条线； 叶子节点必须是黑色，即最下层，NIL 从任一节点出发到其每个叶子节点的路径，黑色节点的数量必须相等 特点： 当你存入数据，删除数据的时候，树的结构就会产生变化，可能会变
红黑树原理简析
那些零零散散的算法
07-15 1967
序言红黑树是一种应用十分广泛的平衡二叉搜索树。大部分语言和库中TreeMap的实现都是使用红黑树，还有Linux、Nginx等也使用了红黑树。 但是红黑树也是一种非常复杂的数据结构，为了保持平衡，在修改的时候必须进行维护操作，插入操作要分5种不同的情况来处理，而删除则有6种情况。 实际上，没有必要沉迷于这十几种情况不能自拔。多数时候，了解红黑树的原理和由来就足够了。因为实际应用中，几乎不可能有需
简析红黑树
Markland_l的博客
03-03 89
红黑树节点 public class RbTreeNode { /** 节点颜色 */ public boolean color; /** 左孩子 */ public RbTreeNode left; /** 右孩子 */ public RbTreeNode right; public int value; /** 父节点 */ public RbTreeNode parent; public RbTreeNod
红黑树简析（可能会有部分转载）
qq_39839310的博客
09-02 193
一. 红黑树的特性 性质1:每个节点或者是黑色，或者是红色。 性质2:根节点是黑色。 性质3:每个叶子节点(NIL)是黑色。[注意:这里叶子节点，是指为空(NIL或NULL)的叶子节点!] 性质4:如果一个节点是红色的，则它的子节点必须是黑色的。 性质5:从一个节点到该节点下的所有叶子节点的路径上，均包含相同数目的黑节点。 对于特性(5)，确保没有一条路径会比其他路径长出两倍。因而，红黑树是相对接近平衡的二叉树。 二. 旋转 红黑树的基本操作是添加、删除。在对红黑树进行添加或删除之后，都会用到旋转
红黑树（七）：删除和性能分析
主要研究图形学相关领域
06-01 224
红黑树（七）：删除
java简析B树、B+树以及红黑树
qq_40997352的博客
03-01 311
java中包含了多种树，但是树设计的目的是为了减少查询的时间，从而达到提升查询效率的目的。此处只做简要的解析。 红黑树通过旋转以及变色，来降低树的高度。（Treeset） 复杂度0（1） B树称为多路搜索树，M路B树的节点中最多有M个子节点，其设计目的也是为了进一步降低树的高度。（普遍用于文件索引中，主要原因是B树在磁盘的速度要优于红黑树，同时由于文件索引中由于数据量大的原因，导致无法一次性加载所有的数据，所以采用多路存储）复杂度log(n) B+树属于B树的进阶版，同时B+树的每个叶子节点上都保有数据，
红黑树代码
03-30
红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树...
红黑树详解
09-02
红黑树详解（带目录源码） 本文适合那些有对二叉树有一定的基础，并且熟悉C语言的读者。本文最主要的参考资料是《Introduction to Algorithms 3rd Edition》。
红黑树生成删除
07-04
红黑树在线生成的一个工具，从网上找的，我这样应该得不到分。大哭https://www.cnblogs.com/bbvi/p/5576201.html 删除可能存在问题，替换节点的兄弟节点为黑色节点时有问题，其他部分是没有问题的，凑合着看看
红黑树demo python代码
07-12
该资源是一个红黑树的demo程序，包含了红黑树的插入和红黑树的删除过程，实现方式相对比较简单明了，适合于刚刚接触红黑树的入门者阅读。
Golang | Leetcode Golang题解之第67题二进制求和
weixin_66442839的博客
05-04 503
Golang | Leetcode Golang题解之第67题二进制求和
StarryCoding 算法小白周赛2 题解与代码（含视频题解）
最新发布
qq_29495615的博客
05-04 893
因为他会按照“拜访时间安排表”的顺序拜访每一位好友，而无法成功拜访某一好友时，必定是出现靠后拜访的时间早于靠前拜访的，或者两次拜访的时间相同，所以问题的本质就是判断数组是否。），应该删除这个数还是前一个数，因为我们想要的是让后面的数的合法值域更大，所以我们需要最小化留下的那个数，也就是说，如果靠后的数。如果某个数比前一个数小，那么肯定不行，我们需要考虑删去这个元素。如果大于，则最好不要更改，给后面的元素更多的空间。由于数的范围很小，假如这个数合法，我们直接从此数。,能保证加的数量是最少的，并且。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 741
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
c++容器与算法概述
北风
05-01 587
简单讲述输入输出运算符重载 以及容器的简单使用及接口哦苦
红黑树 delphi
12-19
红黑树是一种自平衡二叉查找树，它能够保持在插入或删除操作后依然保持相对平衡的状态，因此在很多情况下能够保证较低的时间复杂度。在 Delphi 中，我们可以通过使用现有的红黑树实现来实现相关的功能。 在 Delphi ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

finish_speech

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值