红黑树

最新推荐文章于 2022-11-20 17:05:30 发布
最新推荐文章于 2022-11-20 17:05:30 发布
阅读量174 收藏
点赞数
分类专栏： 个人理解 作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cat_want_fly/article/details/101943364
版权

之前博客实现了AVL树，但是AVL树的频繁的插入和删除，会引起频繁的rebalance，导致效率下降；红黑树不是高度平衡的，算是一种
折中，插入最多两次旋转，删除最多三次旋转。所以红黑树在查找，插入删除的性能都是O(logn)，且性能稳定，所以STL里面很多结构包括map底层实现都是使用的红黑树。
红黑树也是一种二叉平衡树，它不使用平衡因子来维护树的形状，而是使用红黑节点来决定，使得最长节点的长度不会超过最短节点的长度的两倍，让红黑树的插入和删除大大减少了树的旋转操作，虽然这么做是有代价的，AVL树的时间复杂度为O(logn),而红黑树的时间复杂度为O(nlogn),但是因为日新月异的计算机运算能力的发展，这点损失是可以接受的。

1.红黑树的规则

首先来看红黑树的组成规则

  • 每个节点不是红节点就是黑节点(废话中的废话)
  • 每个红节点的两个孩子节点必须是黑节点(没有连续的红节点)
  • 根节点是黑节点
  • 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点(决定最长节点的长度不会超过最短节点的长度的两倍)
  • 每个叶子结点都是黑色的(此处的叶子结点指的是空结点不是有有效值的节点）

只要我们保证上面的规则，就能决定最长节点的长度不会超过最短节点的长度的两倍，可以从下图看出。
在这里插入图片描述
在每条路径的黑节点个数相同的情况下

  • 最短路径：全部为黑节点
  • 最长路径：在规则允许的情况下尽量插入红节点，最终为红黑相间。

ps：为什么红黑树叫做红黑树，而不叫黑白树，蓝紫树？
答案：因为红黑树的作者就是这么规定的:D.

红黑树的插入

上面的知识是为了用红色和黑色控制树的形状的，从上面的规则可以知道，每棵树的根节点都是黑色的，但是当我们插入一个新的节点，这个新的节点是红色还是黑色？
假如插入的节点为黑色，一定会影响第四条规定，需要将所有路径上的节点重新调整。
假如插入的节点为红色，可能违反第二条规定，如果插入节点的父亲节点为黑色，则无影响，直接结束，否则进行旋转处理。
所以我们插入的新的的节点的颜色为红色，判断父亲节点的颜色，确定是否进行左右旋转，为了方便下面用不同的标识来显示节点。

  • _Proot: 根节点
  • _root ：插入节点
  • pnode： 插入节点的父亲
  • grandfather： 插入节点的父亲的父亲
  • uncle： 插入节点的父亲的兄弟节点

1.插入节点的父亲节点为黑色

下图是我们遇到的最简单的情况，当父节点为黑色时，插入一个红节点不会破坏原来路径的黑节点的个数，而且没有违反规则，插入后，直接退出。
在这里插入图片描述

2.插入节点的父节点为红色，且父节点的兄弟节点也为红色

也是比较简单的一种情况，将父节点和父节点的兄弟节点颜色变为黑色，祖父节点的颜色变为红色。
在这里插入图片描述
但是上面只是一棵树的一部分，改变完成后，还要往上进行调整。
在这里插入图片描述
修改为后，判断是否有两个连续的红色节点，如果没有，将_root pnode gardfather向上移动，直到根节点。

3.新插入的父节点为红色，且父节点的兄弟节点为黑色（单旋）

下图为我们遇到的第三种情况，也就是上图调整后的情况，pnode为红，uncle为黑。
**注意:**这种情况一定是在我们进行的第二种情况调整了红黑节点的颜色产生的，_root绝对不可能是新插入的节点，因为在插入之前这棵树已经不满足红黑树的定义了，所以_root之前是黑色，之后被调整为了红色。
在这里插入图片描述
遇到这种情况的步骤为

  1. 将pnode的右孩子成为grandfather的左孩子
  2. 将pnode的右孩子的父亲指针指向grandfather
  3. 将pnode的父亲指针指向grandfather的父节点，如果grandfather为根节点，则将pnode设为根节点。
  4. 将grandfather的父亲指针指向pnode.
  5. 将pnode的右孩子指向grandfather
  6. 将pnode的颜色变为黑色，grandfather的颜色变为红色
    下面是对应的代码，可以对照的理解

	void _RotateR(Node* pnode)
	{
		Node* ppnode = pnode->_Parents;
		Node* Lnode = pnode->_Left;
		pnode->_Left = Lnode->_Right;
		if (Lnode->_Right)
		{
			Lnode->_Right->_Parents = pnode;
		}
		Lnode->_Right = pnode;

		if (ppnode == nullptr)
		{
			_Proot = Lnode;
			_Proot->_Parents = nullptr;
		}
		else
		{
			Lnode->_Parents = ppnode;
			if (ppnode->_Left == pnode)
			{
				ppnode->_Left = Lnode;
			}
			else if (ppnode->_Right == pnode)
			{
				ppnode->_Right = Lnode;
			}
		}
		pnode->_Parents = Lnode;
		
	}

4.新插入的父节点为红色，且父节点的兄弟节点为黑色或者不存在（双旋）

和第三种情况一样，只不过要进行两次旋转达到目的。
在这里插入图片描述
这种情况下先对parents为轴进行右旋，再以grandfather为轴进行左旋，最后将grandfather和_root的颜色进行改变。
即使是更复杂的树也是这种改变顺序。
在这里插入图片描述
以上就是修改红黑树遇到的旋转情况，这里拿右单旋和右左单旋为例，左单旋和左右单旋方向想法，思路相同。

2.红黑树的删除

红黑树的删除有一定的难度，这里我们就不详细介绍了，其实它跟二叉搜索树的删除很类似就是寻找一个替换节点然后删掉它的替换节点，如果有兴趣的读者可以查看算法导论的相关章节。

3.红黑树的验证

红黑树的验证是一个难点，并不像AVL树，红黑树不保证一定是一颗平衡二叉树，所以我们可以从下面的规则入手

  1. 根节点是黑色
  2. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
  3. 每个红节点的两个孩子节点必须是黑节点

	bool ISRBtree()
	{
		if (_Proot->_color == RED)//判断根节点是否为黑色
			return false;
		Node* root = _Proot;
		int m, n;
		m = n = 0;
		while (root)
		{
			if (root->_color == BLACK)
				n++;//记录一条路径的黑节点的个数
			root = root->_Left;
		}
		return _ISRBtree(_Proot, m, n);
	}

	bool _ISRBtree(Node* root, int m, int n)
	{
		
		if (root == nullptr)
		{   
			
			if (m == n)
				return true;
			else
				return false;
		}
		else
		{
			if (root->_color == BLACK)
				m++;
			else if (root->_color == RED && root->_Parents && root->_Parents->_color == RED)//判断是否有连续的红节点
			{
				cout << "连续的红节点" << endl;
				return false;
			}
		}
		return _ISRBtree(root->_Left, m, n) && _ISRBtree(root->_Right, m, n);
	}
	
	public:
		Node* _Proot;

};

测试数据

for（int i=0;i<70;i++）

结果：
在这里插入图片描述

4.主体代码

包括构造，插入，验证函数代码和中序遍历代码。（至于删除的代码emmmm… 还在研究中 ?）

template<class K, class V>
struct AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
	{	
		_Proot = nullptr;
	}

	bool Insert(const K& key, const V& value)
	{
		if (_Proot == nullptr)
		{
			_Proot = new Node(key, value);
			_Proot->_color = BLACK;
			return true;
		}
		Node* root = _Proot;

		Node* pnode = nullptr;
		while (root)
		{
			pnode = root;
			if (root->_value > value)
			{
				root = root->_Left;
			}
			else if (root->_value < value)
			{
				root = root->_Right;
			}
			else if (root->_value == value)
				return true;
		}

		root = new Node(key, value);
		root->_color = RED;//可有可无
		if (pnode->_value > value)//改
		{
			pnode->_Left = root;
			root->_Parents = pnode;//不要忘记父子也要连上
		}
		else
		{
			pnode->_Right = root;
			root->_Parents = pnode;
		}


		while (pnode && pnode->_color == RED)//如果插入的父节点为黑色就不需要修改
		{
			Node* grandfather = pnode->_Parents;
			Node* uncle;
			if (pnode == grandfather->_Left)
			{
				uncle = grandfather->_Right;
				//三种情况
				if (uncle && uncle->_color == RED)
				{
					uncle->_color = BLACK;
					pnode->_color = BLACK;
					grandfather->_color = RED;
					root = grandfather;
					pnode = root->_Parents;
				}
				else
				{
					if (root == pnode->_Right)
					{
						_RotateL(pnode);
						swap(root, pnode);//完成
					}
					_RotateR(grandfather);
					grandfather->_color = RED;
					pnode->_color = BLACK;
					break;
				}

			}
			else if (pnode == grandfather->_Right)
			{
				uncle = grandfather->_Left;
				//三种情况
				if (uncle && uncle->_color == RED)
				{
					uncle->_color = BLACK;
					pnode->_color = BLACK;
					grandfather->_color = RED;
					root = grandfather;
					pnode = root->_Parents;
				}
				else
				{
					if (root == pnode->_Left)
					{
						_RotateR(pnode);
						swap(root, pnode);//完成
					}
					_RotateL(grandfather);
					grandfather->_color = RED;
					pnode->_color = BLACK;
					break;
				}

			}

			_Proot->_color = BLACK;
			
		}
		return true;
	}
	

	void _RotateL(Node* pnode)
	{
		Node* ppnode = pnode->_Parents;
		Node* Rnode = pnode->_Right;
		pnode->_Right = Rnode->_Left;
		if (Rnode->_Left)
		{
			Rnode->_Left->_Parents = pnode;
		}

		Rnode->_Left = pnode;
		pnode->_Parents = Rnode;

		if (ppnode == nullptr)//
		{
			_Proot = Rnode;
			_Proot->_Parents = nullptr;
		}
		else
		{
			if (ppnode->_Left == pnode)
			{
				ppnode->_Left = Rnode;
			}
			else if (ppnode->_Right == pnode)
			{
				ppnode->_Right = Rnode;
			}
			Rnode->_Parents = ppnode;
		}

	}

	void _RotateR(Node* pnode)
	{
		Node* ppnode = pnode->_Parents;
		Node* Lnode = pnode->_Left;
		pnode->_Left = Lnode->_Right;
		if (Lnode->_Right)
		{
			Lnode->_Right->_Parents = pnode;
		}
		Lnode->_Right = pnode;

		if (ppnode == nullptr)
		{
			_Proot = Lnode;
			_Proot->_Parents = nullptr;
		}
		else
		{
			Lnode->_Parents = ppnode;
			if (ppnode->_Left == pnode)
			{
				ppnode->_Left = Lnode;
			}
			else if (ppnode->_Right == pnode)
			{
				ppnode->_Right = Lnode;
			}
		}
		pnode->_Parents = Lnode;
		
	}

	void _RotateRL(Node* pnode)
	{
		_RotateR(pnode->_Right);
		_RotateL(pnode);

	}

	void _RotateLR(Node* pnode)
	{

		_RotateL(pnode->_Right);
		_RotateR(pnode);
	}
	void showtree()
	{
		Node* root = _Proot;
		_show(root);
	}

	void _show(Node* root)
	{
		if (nullptr == root)
			return;
		_show(root->_Left);

		cout << root->_value<<" ";

		_show(root->_Right);


	}
	bool _IsBlanace(Node* root)//代码就不在详细解答了，一个简单的判断问题
	{
		if (root == nullptr)
			return true;
		int leftHeight = _Height(_Proot->_Left);
		int rightHeight = _Height(_Proot->_Right);
		
		return 10*leftHeight / rightHeight <= 20 || 10 * leftHeight / rightHeight >= 5 && _IsBlanace(root->_Left) && _IsBlanace(root->_Right);
	}
	int _Height(Node* root) {
		if (root == nullptr) {
			return 0;
		}

		int leftheight = _Height(root->_Left);
		int rightheight = _Height(root->_Right);
		int i = leftheight > rightheight ? leftheight + 1 : rightheight + 1;

		
		return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
	}

	bool ISRBtree()
	{
		if (_Proot->_color == RED)
			return false;
		Node* root = _Proot;
		int m, n;
		m = n = 0;
		while (root)
		{
			if (root->_color == BLACK)
				n++;
			root = root->_Left;
		}
		return _ISRBtree(_Proot, m, n);
	}

	bool _ISRBtree(Node* root, int m, int n)
	{
		
		if (root == nullptr)
		{   //cout << m << endl;
			
			if (m == n)
				return true;
			else
				return false;
		}
		else
		{
			if (root->_color == BLACK)
				m++;
			else if (root->_color == RED && root->_Parents && root->_Parents->_color == RED)
			{
				cout << "连续的红节点" << endl;
				return false;
			}
		}
		return _ISRBtree(root->_Left, m, n) && _ISRBtree(root->_Right, m, n);
	}
	
	public:
		Node* _Proot;

};
心怀梦想的咸鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树详解
09-02
红黑树详解（带目录源码） 本文适合那些有对二叉树有一定的基础，并且熟悉C语言的读者。本文最主要的参考资料是《Introduction to Algorithms 3rd Edition》。
红黑树的实现（C++）
青衫客36的博客
04-13 194
【代码】红黑树的实现（C++）
用C++实现红黑树的插入操作以及红黑树的验证
TANGY的博客
02-07 358
1.红黑树的概念 红黑树是一种二叉搜索树，并且每个结点上增加了一个存储表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径的长度长出两倍，因而是近似平衡的。 2.红黑树的性质（重要） 每个结点的颜色不是红色就是黑色 根结点的颜色是黑的 如果一个结点是红的，则它的两个孩子结点是黑的（意思是不可能存在连续的红结点...
红黑树的插入（C++实现）
Man9o
11-20 651
和实现AVL树结点类类似，依然使用pair键值对作为结点值的部分。必要时，红黑树依然要进行旋转，所以和AVL一样，也要定义一个parent变量，用于存放结点的父结点的地址。除此之外，红黑树新增了一个_col变量，用于表示结点的颜色。在此，使用枚举常量保存颜色。enum Color // 使用枚举 {// 红黑树结点类 template < class K , class V > struct RBTreeNode {// 颜色 pair < K , V > _kv;
红黑树（RBTree）原理及实现
weixin_52259848的博客
07-08 2462
红黑树（RBTree）原理及实现
数据结构 红黑树（RBTree）的原理与实现
WhiteShirtI的博客
05-20 932
学习红黑树之前你应该保证你学过AVL树，也就是平衡二叉搜索树 数据结构 AVL树 AVL树是一棵高度平衡的二叉搜索树，其要求每个结点的高度差不能大于1，这样子就保证了其查询的时间复杂度为log2(N)，不会出现单支树而导致时间复杂度退化到线性时间。但是AVL树的插入和删除性能非常低下，只要稍微不平衡，都需要进行旋转操作，实现起来也相对困难。所以如果当你需要查询效率高且有序时你可以有优先选择AVL树，但是如果你所需的数据结构是频繁的插入与删除，且需要高效查询且有序时，你可以优先考虑红黑树（RBTree） 红黑
红黑树代码
03-30
红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树...
C语言实现红黑树的实例代码
12-25
因为看内核的时候感觉红黑树挺有意思的，所以利用周末的时间来实现一下玩玩。红黑树的操作主要是插入和删除，而删除的时候需要考虑的情况更多一些。具体的操作就不在这里罗嗦了，百度文库里面有一个比较有好的文章，...
红黑树demo python代码
07-12
该资源是一个红黑树的demo程序，包含了红黑树的插入和红黑树的删除过程，实现方式相对比较简单明了，适合于刚刚接触红黑树的入门者阅读。
红黑树生成删除
07-04
红黑树在线生成的一个工具，从网上找的，我这样应该得不到分。大哭https://www.cnblogs.com/bbvi/p/5576201.html 删除可能存在问题，替换节点的兄弟节点为黑色节点时有问题，其他部分是没有问题的，凑合着看看
是否二叉搜索树（注意思路）
ljhsq的博客
03-30 148
是否二叉搜索树题目答案注意错误思路正确思路 题目 答案 bool IsBST ( BinTree T ) { if(!T) return true; else if(!T->Left&&!T->Right) return true; BinTree BT1=T->Left,BT2=T->Right; if(BT1) { while(BT1->Right) BT1=BT1->Right; } if(BT2) { whil
习题4.3 是否二叉搜索树（25 分）
yubai258的博客
08-26 471
bool IsBST ( BinTree T ) {   BinTree max,min;   if(!T) return true;   else   {     if(T-&gt;Left&amp;&amp;T-&gt;Right)     {       max=T-&gt;Left;       min=T-&gt;Right;       while(max-&gt;Right)    ...
【C++/STL】手撕红黑树
qq_53893431的博客
08-05 622
STL/红黑树
手撕红黑树（Red-Black Tree）
林慢慢的博客
07-06 2601
红黑树 （C++实现）
408数据结构学习笔记——二叉排序树、二叉平衡树、红黑树
JiangNan_1002的博客
04-16 3806
1.二叉排序树 2.平衡二叉树 3.红黑树 4.王道课后题
红黑树（RBTree）的插入算法以及如何测试一棵树是否是红黑树？（详细图解说明）
sky_Mata的博客
06-02 5076
红黑树的插入数据时，什么时候该调整，什么时候不用调整，什么时候需要旋转，该怎样调节结点的颜色呢？以及如何判断一棵树是否是红黑树，超级详细的图解过程！！！
RBTree(红黑树)
sowhat
04-04 844
http://www.linuxidc.com/Linux/2017-01/139950.htm 红黑树        红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是Red或Black。通过对任何一条从根到叶子简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似于平衡。 红黑树是满足下面红黑性质的二叉搜索树：
【数据结构】模拟实现红黑树（RBTree）的插入算法
sofia_m的博客
04-20 1549
1、红黑树基本概念 含义： 首先红黑树是一棵二叉搜索树，它在每一个节点上增加了一个存储位来表示节点的颜色（red 或 black）。红黑树通过对任何一条从根节点到叶子节点简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似平衡，而且在实际应用中发现红黑树性能确实比AVL树性能高。 【数据结构】二叉搜索树的插入，删除，查找等基本操作的实现 【数据结构】AVL树的平衡化...
RBTree（红黑树的简单实现）
YangGangAVA的博客
09-13 373
自己实现的简单红黑树，只进行了插入和打印相关操作的实现，删除比较麻烦，可以root节点里增加useNode和capacity来记录使用的节点和总结点个数，在子节点中加入flag来标注该节点是否已经使用，当useNode和capacity达到一定比例的时候对整棵树进行重构。
红黑树 delphi
最新发布
12-19
红黑树是一种自平衡二叉查找树，它能够保持在插入或删除操作后依然保持相对平衡的状态，因此在很多情况下能够保证较低的时间复杂度。在 Delphi 中，我们可以通过使用现有的红黑树实现来实现相关的功能。 在 Delphi ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值