红黑树剖析

已于 2024-09-04 10:15:52 修改
阅读量1.1k 收藏 29
点赞数 20
分类专栏： C嘎嘎 文章标签： c++ 数据结构
于 2024-04-02 09:15:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_75172965/article/details/137237225
版权

目录

一.   红黑树的概念

 二.   红黑树的性质

三.   红黑树节点的定义

四.   红黑树的插入操作

 4.1        uncle存在且颜色为红

4.2        uncle不存在或者uncle存在且为黑

五.   整体代码展示

一.   红黑树的概念

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

 

 二.   红黑树的性质

（1）每个节点是黑色和红色中的一种

（2）根节点是黑色的

（3）红节点的子节点必须是黑节点（不能出现两个连续的红节点）

（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)
		,_kv(kv)
		,_col(RED)
	{}
};

我们可以看见，创建新节点时，我们默认给的颜色是红色，为什么呢？

那是因为如果我们给的是黑色，就会导致左右子树的黑色节点数目不相等，与红黑树的性质相违背。

四.   红黑树的插入操作

由于红黑树除了插入操作以外，其余操作与搜索二叉树类似，所以这里讲插入操作。

那我们插入红色节点之后，是否对树的结构造成了破坏呢？

可以看见，如果父亲节点是黑色的，那实际上是不会破坏结构的，而如果父亲节点是红色，就违背了性质三（不能有连续的两个红色节点），这时候就要调节树的结构。

 父亲节点为红色时，就要调节树的结构，我们先对节点起个名字。

约定：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

 4.1        uncle存在且颜色为红

代码展示（由于parent和uncle是grandparent的左还是右不影响结果，所以这里让parent为左，uncle为右）：

Node* grandparent = parent->_parent;
Node* uncle = nullptr;
if (uncle && uncle->_col == RED)
{
	parent->_col = BLACK;
	uncle->_col = BLACK;
	grandparent->_col = RED;
	if (grandparent == _root)
	{
		grandparent->_col = BLACK;
	}
	else
	{
		cur = grandparent;
		parent = cur->_parent;//迭代上去
	}
}

总结：当uncle存在且为红时，我们需要把parent和uncle变为黑色，grandparent变为红色，如果grandparent为根节点，则再次把他的颜色变为黑色，如果不是，则令cur=grandparent，迭代上去直到根节点。 

4.2        uncle不存在或者uncle存在且为黑

代码展示（同上parent为左，uncle为右，这里要分cur是parent的左还是右）： 

else
{
	//		g
	//	p		u
	//c
	if (cur == parent->_left)
	{
		RotaleR(grandparent);
		parent->_col = BLACK;
		grandparent->_col = RED;
	}
	//		g
	//	p		u
	//		c
	else
	{
		RotaleL(parent);
		RotaleR(grandparent);
		cur->_col = BLACK;
		grandparent->_col = RED;
	}
	break;
}

void RotaleL(Node* parent)
{
	rotalSize++;
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	parent->_right = subRL;
	subR->_left = parent;
	if (subRL)
	{
		subRL->_parent = parent;
	}
	Node* ppnode = parent->_parent;
	parent->_parent = subR;
	if (parent == _root)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else
	{
		if (parent == ppnode->_left)
		{
			ppnode->_left = subR;
		}
		else if (parent == ppnode->_right)
		{
			ppnode->_right = subR;
		}
		subR->_parent = ppnode;
	}
}
void RotaleR(Node* parent)
{
	rotalSize++;
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	parent->_left = subLR;
	subL->_right = parent;
	if (subLR)
	{
		subLR->_parent = parent;
	}
	Node* ppnode = parent->_parent;
	parent->_parent = subL;
	if (parent == _root)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (ppnode->_left == parent)
		{
			ppnode->_left = subL;
		}
		else if (ppnode->_right == parent)
		{
			ppnode->_right = subL;
		}
		subL->_parent = ppnode;
	}
}

总结：对于cur是parent左节点的情况，需要将这棵树在grandparent右旋，并将grandparent的颜色变为红色，parent的颜色变为黑色；对于cur是parent右节点的情况，单一的旋转不能满足条件了，此时需要先将这棵树在parent左旋，再在grandparent处右旋，并将grandparent的颜色变为红色，cur的颜色变为黑色。

五.   整体代码展示

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)
		,_kv(kv)
		,_col(RED)
	{}
};
template<class K,class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
    bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			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* grandparent = parent->_parent;
			Node* uncle = nullptr;
			//parent和uncle是grandparent的左还是右不影响结果
			//cur是parent的左还是右不影响结果
			if (parent == grandparent->_left)
			{
				uncle = grandparent->_right;
				//uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandparent->_col = RED;
					if (grandparent == _root)
					{
						grandparent->_col = BLACK;
					}
					else
					{
						cur = grandparent;
						parent = cur->_parent;
					}
				}
				else
				{
					//		g
					//	p		u
					//c
					if (cur == parent->_left)
					{
						RotaleR(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
					//		g
					//	p		u
					//		c
					else
					{
						RotaleL(parent);
						RotaleR(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
			else
			{
				uncle = grandparent->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandparent->_col = RED;
					if (grandparent == _root)
					{
						grandparent->_col = BLACK;
					}
					else
					{
						cur = grandparent;
						parent = cur->_parent;
					}
				}
				else
				{
					//		g
					//	u		p
					//				c
					if (cur == parent->_right)
					{
						RotaleL(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
					//		g
					//	u		p
					//		c
					else
					{
						RotaleR(parent);
						RotaleL(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
		}
		return true;
	}
	void RotaleL(Node* parent)
	{
		rotalSize++;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		subR->_left = parent;
		if (subRL)
		{
			subRL->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		parent->_parent = subR;
		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == ppnode->_left)
			{
				ppnode->_left = subR;
			}
			else if (parent == ppnode->_right)
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}
	void RotaleR(Node* parent)
	{
		rotalSize++;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		subL->_right = parent;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		Node* ppnode = parent->_parent;
		parent->_parent = subL;
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else if (ppnode->_right == parent)
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << endl;
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
	}
	bool _check(Node* root,int blackNum,int refBlackNum)
	{
		if (root == nullptr)
		{
			if (blackNum != refBlackNum)
			{
				cout <<"黑色节点数目不同" << endl;
				return false;
			}
			//cout << blackNum << endl;
			return true;
		}
		else if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}
		if (root->_col == BLACK)
		{
			blackNum++;
		}
		return _check(root->_left,blackNum,refBlackNum) 
			&& _check(root->_right, blackNum,refBlackNum);
	}
	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			return false;
		}
		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if(cur->_col==BLACK)
				refBlackNum++;
			cur = cur->_left;
		}
		return _check(_root,0,refBlackNum);
	}
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return NULL;
	}
private:
	Node* _root=nullptr;
	size_t rotalSize=0;
};

 总结

好了，到这里今天的知识就讲完了，大家有错误一点要在评论指出，我怕我一人搁这瞎bb，没人告诉我错误就寄了。

祝大家越来越好，不用关注我（疯狂暗示）

小灵蛇
关注
专栏目录
红黑树分析笔记
melodylzl的博客
07-06 240
阅读本文的前提 1、知道二叉查找树的概念，插入、删除和查找操作； 2、知道二叉树的左旋和右旋。 3、了解二叉平衡树（AVL树）的概念 红黑树的概念 红黑树是一种自平衡的二叉查找树，查找、插入和删除的平均时间复杂度是O(logN)。红黑树的每个节点都有一个颜色值（红或黑），具有以下性质： 1、每个节点不是黑色就是红色； 2、根节点是黑色； 3、如果一个节点是红色，则该节点的左、右孩子节点必须是黑色； 4、每一个null叶子节点是黑色； 5、从任一个节点到null叶子节点的所有路径上必须包含相同数量的黑色节点。
红黑树分析
07-03
红黑树分析 代码
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 21万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
C++红黑树
~
03-26 6705
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树介绍
mz474920631的博客
05-28 4万+
红黑树一、红黑树的概念红黑树的性质红黑树节点的定义红黑树结构二、使用步骤1.引入库2.读入数据总结 一、红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数
图解红黑树
Dablelv 的博客专栏。
08-10 1765
1.红黑树简介 红黑树（Red Black Tree）是一种含有红黑结点并能自平衡二叉查找树，典型的用途是实现 map。 它必须满足下面规则： 规则1：每个结点要么是黑色，要么是红色。 规则2：根结点是黑色。 规则3：每个叶子结点（NIL）是黑色。 规则4：每个红色结点的两个子结点都是黑色。 规则5：任意一结点到每个叶子结点的路径都包含相同数量的黑结点。 记住上面的规则也不难，我们会发现黑色结点非常特殊，规则1即“非红即黑”，规则2和3即“首尾全黑”，规则4即“红子双黑”，规则5即“路径等黑”。 这些规则
红黑树简介
Charge8的博客
12-28 851
红黑树简介
C语言 红黑树分析与实现
C++ 开发者的博客
12-11 1100
重要概念 红黑树的资料网上资料很多，对红黑树的定义、性质、以及操作都做了详细的分析，这篇博文也参考了网上的很多文章，不过主要是学习了腾讯课堂-零声king老师的课之后，对红黑树的一些理解。肯定有一些错误的地方，如果觉得不对，可以给我指出。 参考资料 如果你对红黑树的基本概念，用途，性质等不了解，那么请先看红黑树(一)之 原理和算法详细介绍的文章，里面对红黑树的了解很仔细，这篇博客主要是用C语言来实现红黑树。 红黑树性质 （1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（NIL
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未...通过阅读和分析提供的代码，我们可以更好地理解和应用红黑树。
红黑树：红黑树的Matlab实现-matlab开发
05-30
红黑树是一种自平衡二叉查找树，...通过阅读和分析这些代码，我们可以深入理解红黑树的内部工作机制和Matlab面向对象编程的应用。对于学习数据结构和算法，以及提升Matlab编程技能来说，这是一个非常有价值的实践案例。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 926
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 155
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
C++：图的最短路径问题
han2205277149的博客
10-04 1056
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 928
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 663
【C++】stack和queue的使用及注意事项
C - Separated Lunch
最新发布
m0_74304371的博客
10-05 223
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
Java实现的红黑树算法深入分析
"红黑树算法实现 - 李刚 - IBM developerWorks" 红黑树是一种自平衡的二叉查找树，它的每个节点都带有颜色属性，可以是红色或黑色。这种数据结构确保了在进行插入、删除操作时，能通过特定的调整规则保持树的平衡，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值