数据结构：红黑树实现

已于 2022-08-07 19:38:47 修改
阅读量138 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2022-08-07 19:36:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69414302/article/details/126215820
版权

红黑树的特性：

1.每个结点非红即黑

2.根结点为黑色

3.所有叶子结点为黑色

4.父子不同红

5.任意结点，从该结点到所有子孙结点路径上的黑色结点数量相同

下面请看详细代码（其中包含了注释）（需要用到二叉树旋转请跳转）二叉树的旋转

#include <iostream>
using namespace std;

enum COLOR {RED,BLACK};
struct RBT
{
	int value;
	RBT* pFather;
	RBT* pLeft;
	RBT* pRight;
	COLOR color;
};
RBT* GetFather(RBT* pRoot, int value)
{
	while (pRoot != nullptr)
	{
		if (value < pRoot->value)
		{
			if (pRoot->pLeft == nullptr)
			{
				return pRoot;
			}
			pRoot = pRoot->pLeft;
		}
		else if(value > pRoot->value)
		{
			if (pRoot->pRight == nullptr)
			{
				return pRoot;
			}
			pRoot = pRoot->pRight;
		}
		else
		{
			cout << "数据有误" << endl;
			break;
		}
	}
	return nullptr;
}
RBT* GetUncle(RBT* pRoot)
{	
	if (pRoot == nullptr || pRoot->pFather == nullptr || pRoot->pFather->pFather == nullptr)
	{
		return nullptr;
	}
	if (pRoot->pFather->pFather->pLeft == pRoot->pFather)
	{
		return pRoot->pFather->pFather->pRight;
	}
	else
	{
		return pRoot->pFather->pFather->pLeft;
	}
}
void RightRotate(RBT* pRBT,RBT*& rpRoot)
{
	if (pRBT == nullptr || pRBT->pLeft == nullptr)
	{
		return;
	}
	RBT* pMark = pRBT;
	RBT* pTemp = pRBT->pLeft;

	pMark->pLeft = pTemp->pRight;
	pTemp->pRight = pMark;
	if (pMark->pFather == nullptr)
	{
		rpRoot = pTemp;
	}
	else
	{
		if (pMark->pFather->pLeft == pMark)
		{
			pMark->pFather->pLeft = pTemp;
		}
		else
		{
			pMark->pFather->pRight = pTemp;
		}
	}
	if (pMark->pLeft != nullptr)
	{
		pMark->pLeft->pFather = pMark;
	}
	pTemp->pFather = pMark->pFather;
	pMark->pFather = pTemp;
}
void LeftRotate(RBT* pRBT, RBT*& rpRoot)
{
	if (pRBT == nullptr || pRBT->pRight == nullptr)
	{
		return;
	}
	RBT* pMark = pRBT;
	RBT* pTemp = pRBT->pRight;

	pMark->pRight = pTemp->pLeft;
	pTemp->pLeft = pMark;
	if (pMark->pFather == nullptr)
	{
		rpRoot = pTemp;
	}
	else
	{
		if (pMark->pFather->pLeft == pMark)
		{
			pMark->pFather->pLeft = pTemp;
		}
		else
		{
			pMark->pFather->pRight = pTemp;
		}
	}
	if (pMark->pRight != nullptr)
	{
		pMark->pRight->pFather = pMark;
	}
	pTemp->pFather = pMark->pFather;
	pMark->pFather = pTemp;
}
void AddRBT(RBT*& rpRoot, int value)
{
	//获得父亲
	RBT* pFather = GetFather(rpRoot, value);
	//创建结点
	RBT* pMark = new RBT;
	pMark->value = value;
	pMark->color = RED;
	pMark->pFather = pFather;
	pMark->pLeft = nullptr;
	pMark->pRight = nullptr;

	//判断空树
	if (rpRoot == nullptr)
	{
		//结点为根 变黑
		pMark->color = BLACK;
		rpRoot = pMark;
		return;
	}
	//非空
	//放入
	if (pMark->value < pFather->value)
	{
		pFather->pLeft = pMark;
	}
	else
	{
		pFather->pRight = pMark;
	}
	while (1)
	{
		//判断父亲颜色
		pFather = pMark->pFather;
		//父亲是黑的   结束
		if (pFather->color == BLACK)
		{
			return;
		}
		//父亲是红的
		//判断叔叔颜色
		RBT* pUncle = GetUncle(pMark);
		//叔叔红色
		if (pUncle != nullptr && pUncle->color == RED)
		{
			//父亲和叔叔变黑
			pFather->color = BLACK;
			pUncle->color = BLACK;
			//爷爷变红
			pFather->pFather->color = RED;
			//爷爷为新标记 
			pMark = pFather->pFather;
			//判断新标记是否为根
			if (pMark->pFather == nullptr)
			{
				//爷爷为根 变黑 结束
				pMark->color = BLACK;
				return;
			}
			continue;
		}
	 
		//叔叔是黑的（包含空）
		if (pUncle == nullptr || pUncle->color == BLACK)
		{

			//判断父亲方向
			//父亲是爷爷的左
			if (pFather->pFather->pLeft == pFather)
			{
				//判断标记的方向
				//标记是父亲的右
				if (pMark == pFather->pRight)
				{
					//父亲为新标记
					pMark = pFather;
					//以标记为支点左旋
					LeftRotate(pMark, rpRoot);
				}
				else//标记是父亲的左
				{
					//标记的爷爷变红
					pMark->pFather->pFather->color = RED;
					//标记的父亲变黑
					pMark->pFather->color = BLACK;
					//以标记的爷爷为支点右旋  结束
					RightRotate(pMark->pFather->pFather, rpRoot);
					return;
				}
			}

			//判断父亲方向
			//父亲是爷爷的右
			if (pFather->pFather->pRight == pFather)
			{
				//判断标记的方向
				//标记是父亲的左
				if (pMark == pFather->pLeft)
				{
					//父亲为新标记
					pMark = pFather;
					//以标记为支点右旋
					RightRotate(pMark, rpRoot);
				}
				else//标记是父亲的右
				{
					//标记的爷爷变红
					pMark->pFather->pFather->color = RED;
					//标记的父亲变黑
					pMark->pFather->color = BLACK;
					//以标记的爷爷为支点左旋  结束
					LeftRotate(pMark->pFather->pFather, rpRoot);
					return;
				}
			}
		}
	}
}		

ostream& operator<<(ostream& os, COLOR color)
{
	if (color == RED)
	{
		os << "红";
	}
	else
	{
		os << "黑";
	}
	return os;
}
void InOrder(RBT* pRoot)
{
	if (pRoot == nullptr)
	{
		return;
	}
	InOrder(pRoot->pLeft);
	cout << pRoot->value << "\t" << pRoot->color << endl;
	InOrder(pRoot->pRight);
}

RBT* GetDeleteNode(RBT* pRoot, int value)
{
	while (pRoot != nullptr)
	{
		if (value < pRoot->value)
		{
			pRoot = pRoot->pLeft;
		}
		else if (value > pRoot->value)
		{
			pRoot = pRoot->pRight;
		}
		else
		{
			return pRoot;
		}
	}
	return nullptr;
}

RBT* GetBrother(RBT* pRoot)
{
	if (pRoot == nullptr || pRoot->pFather == nullptr)
	{
		return nullptr;
	}
	return pRoot == pRoot->pFather->pLeft ? pRoot->pFather->pRight : pRoot->pFather->pLeft;
}
void DeleteRBT(RBT* rpRoot, int value)
{
	//找到要删除的结点
	RBT* pDel = GetDeleteNode(rpRoot, value);
	if (pDel == nullptr)
	{
		return;
	}
	//如果删除结点有两个孩子  替换删除结点
	if (pDel->pLeft != nullptr && pDel->pRight != nullptr)
	{
		RBT* pMark = pDel;
		pDel = pDel->pRight;
		while (pDel->pLeft != nullptr)
		{
			pDel = pDel->pLeft;
		}
		pMark->value = pDel->value;
	}

	//根
	if (pDel->pFather == nullptr)
	{
		//判断是否有一个孩子
		if (pDel->pLeft == nullptr && pDel->pRight == nullptr)
		{
			rpRoot = nullptr;
		}
		else
		{
			rpRoot = pDel->pLeft != nullptr ? pDel->pLeft : pDel->pRight;
			rpRoot->color = BLACK;
			rpRoot->pFather = nullptr;
		}

		//删除  新根
		delete pDel;
		pDel = nullptr;
		return;
	}

	RBT* pFather = pDel->pFather;
	//非根
	//分析删除结点颜色
	if (pDel->color == RED)
	{
		//红
		//直接删除
		if (pDel == pFather->pLeft)
		{
			pFather->pLeft = nullptr;
		}
		else
		{
			pFather->pRight = nullptr;
		}
		delete pDel;
		pDel = nullptr;	
		return;
	}
	//黑  判断是否有孩子
	//有孩子  一定是红孩子
	if (pDel->pLeft != nullptr || pDel->pRight != nullptr)
	{
		//红孩子变黑  与爷爷相连  删除标记
		RBT* pChild = pDel->pLeft != nullptr ? pDel->pLeft : pDel->pRight;
		pChild->color = BLACK;
		pChild->pFather = pFather;
		if (pFather->pLeft == pFather)
		{
			pFather->pLeft = pChild;
		}
		else
		{
			pFather->pRight = pChild;
		}
		delete pDel;
		pDel = nullptr;
		return;
	}

	//没有孩子
	//分析兄弟情况
	//先获得兄弟   删除结点
	RBT* pBrother = GetBrother(pDel);
	if (pFather->pLeft == pDel)
	{
		pFather->pLeft = nullptr;
	}
	else
	{
		pFather->pRight = nullptr;
	}

	//调整  loop
	while (1)
	{
		//兄弟为红   父亲变红   兄弟变黑   分析兄弟方向
		if (pBrother->color == RED)
		{
			pFather->color = RED;
			pBrother->color = BLACK;
			//兄弟为父亲的右  以父亲为支点左旋  更换兄弟  兄弟为父亲的右  继续分析
			if (pFather->pRight == pBrother)
			{
				LeftRotate(pFather, rpRoot);
				pBrother = pFather->pRight;
			}
			//兄弟为父亲的左  以父亲为支点右旋  更换兄弟  兄弟为父亲的左  继续分析
			else
			{
				RightRotate(pFather, rpRoot);
				pBrother = pFather->pLeft;
			}
			continue;
		}


		//兄弟为黑   分析两个侄子的颜色
		if (pBrother->color == BLACK)
		{
			//两个侄子全黑（包括全空）  分析父亲颜色
			if ((pBrother->pLeft == nullptr && pBrother->pRight == nullptr) || 
				((pBrother->pLeft != nullptr && pBrother->pLeft->color == BLACK) &&
				 (pBrother->pRight != nullptr && pBrother->pRight->color == BLACK)))
			{
				//父亲为红   父亲变黑   兄弟变红   结束
				if (pFather->color == RED)
				{
					pFather->color = BLACK;
					pBrother->color = RED;
				}
				//父亲为黑   兄弟变红   父亲为新的标记   跟换兄弟   标记为根结束  不为根继续分析
				else
				{
					pBrother->color = RED;
					pDel = pFather;
					if (pDel->pFather == nullptr)
					{
						return;
					}
					continue;
				}
			}
			
			

			//左侄子红右侄子黑（包括空）   分析兄弟方向
			if (pBrother->pLeft != nullptr && pBrother->pLeft->color == RED &&
			   (pBrother->pRight == nullptr || pBrother->color == BLACK))
			{
				//兄弟是父亲的右   兄弟变红  左侄子变黑   以兄弟为支点右旋   更换兄弟   继续分析
				if (pBrother == pFather->pRight)
				{
					pBrother->color = RED;
					pBrother->pLeft->color = BLACK;
					RightRotate(pBrother, rpRoot);
					pBrother = pFather->pRight;
					continue;
				}
				//兄弟是父亲的左   父亲颜色给兄弟   父亲变黑   左侄子变黑   以父亲为支点右旋  结束
				if (pBrother == pFather->pLeft)
				{
					pBrother->color = pFather->color;
					pFather->color = BLACK;
					pBrother->pLeft->color = BLACK;
					RightRotate(pFather, rpRoot);
					return;
				}
			}
			

			//右侄子红   分析兄弟方向
			if (pBrother->pRight != nullptr && pBrother->pRight->color == RED)
			{
				//兄弟是父亲的左   兄弟变红   右侄子变黑   以兄弟为支点左旋   更换兄弟   继续分析
				if (pBrother == pFather->pLeft)
				{
					pBrother->color = RED;
					pBrother->pRight->color = BLACK;
					LeftRotate(pBrother, rpRoot);
					pBrother = pFather->pLeft;
					continue;
				}
				//兄弟是父亲的右   父亲颜色给兄弟   父亲变黑   右侄子变黑   以父亲为支点左旋  结束
				if(pBrother == pFather->pRight)
				{
					pBrother->color = pFather->color;
					pFather->color = BLACK;
					pBrother->pRight->color = BLACK;
					return;
				}
			}
			
			
		}
		 
			
			
	}
	



}

	
int main()
{
	RBT* pRoot = nullptr;

	int arr[] = { 11,2,14,1,7,15,5,8 };

	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		AddRBT(pRoot, arr[i]);
	}

	AddRBT(pRoot, 4);

	InOrder(pRoot);
	cout << "----------------------------------" << endl;
	//DeleteRBT(pRoot, 11);
	
	///RBT* pBrother = GetBrother(pRoot->pRight);
	DeleteRBT(pRoot, 4);

	InOrder(pRoot);
	

	


	return 0;
}

@布响丸辣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
底层实现红黑树_数据结构篇：TreeMap的底层实现---红黑树（一）
weixin_34526152的博客
12-24 535
1.简介红黑树是一种自平衡二叉查找树，它的统计性能要好于平衡二叉树(AVL树)，它的操作有着良好的最坏情况运行时间，并且在实践中是高效的：它可以在 O(log n)时间内做查找，插入和删除等操作。2.红黑树的性质：总的来说，红黑树是一种满足以下五个性质的二叉查找树：性质1：每个节点是红的或者黑色性质2：根是黑色性质3：所有叶子都是黑色(叶子是NIL节点)性质4：如果一个节点是红的，则它的...
红黑树
深耕技术
03-03 258
面试：你懂什么是分布式系统吗？Redis分布式锁都不会？>>> 1. 简介 红黑树是一种自平衡二叉查找树。它的统计性能要好于平衡二叉树（AVL树），因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操...
数据结构之红黑树的实现
落叶知秋深的博客
08-16 414
#include&lt;iostream&gt; using namespace std; #include&lt;assert.h&gt; enum color{ RED, BLACK, }; template&lt;class K, class V&gt; struct TreeNode{ public: TreeNode&lt;K, V&gt;* _left; ...
数据结构：红黑树（Red Black Tree）
Gabriel.Tian的博客
07-29 483
概念 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。它可以在O(log n)时间内（它的查找最坏时间复杂度为O(2lgn)）做查找，插入和删除，这里的n 是树中元素的数目。 性质 节点是红色或黑色。 根节点是黑色...
数据结构——红黑树
stromSLR的博客
03-06 4543
数据结构——红黑树 前言 红黑树是map，set，mutilmap，mutilset容器的底层数据结构，也是一种非常重要的数据结构，它在效率上对AVL又做了进一步的优化，因为AVL结构在插入，或删除时，无法避免大量的旋转操作，导致效率有所损耗，但是红黑树，就在这一点有了更好的优化，但是牺牲了平衡性，所以是不是一个完全平衡的二叉搜索树。 一、红黑树的概念和性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色
数据结构-红黑树.zip
最新发布
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
数据结构之红黑树详解
09-04
数据结构中的红黑树是一种特殊的自平衡二叉查找树，它的设计目的是为了在维护高效查找、插入和删除操作的同时，保持树的平衡性。相比于传统的平衡二叉查找树（如AVL树），红黑树在统计性能上有优势，因此被广泛应用...
红黑树-基于Java实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于Java实现的红黑树数据结构
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于C语言实现的红黑树数据结构
红黑树-基于C++实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于C++实现的红黑树数据结构
数据结构(十 一) ---[实现红黑树(Red Black Tree)]
从零开始的异世界JAVA学习
12-22 542
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找
[数据结构]红黑树图解及其代码实现
Protein_zmm的博客
08-16 570
红黑树插入、旋转、调整等分析图解及其代码实现
底层实现数据结构：红黑树
ChanYipFan的博客
04-18 987
学习某个知识（比如红黑树），一上来就扔给你5个定义（就算算法导论那样），告诉你这就是红黑树，然后又从这5个定义推出更多定义。其实这会让学习者很难理解到底什么是红黑树的，这样最大的问题就在于没有介绍清楚这个红黑树是从哪来的，我们为什么要把节点定义成红色或黑色。 2-3树插入元素： 一个原则: 添加节点将永远不会添加到一个空的位置(和二叉搜索树不同)、只会和最后找到的叶子节点做融合：...
数据结构之红黑树——红黑树是2-3-4B树的一种实现
xiaoyaocbc的博客
10-25 859
红黑规则是很好理解的，死记硬背也能背下来，但是如果放到复杂的实际应用中可能我们就懵了。今天在看一篇文章后，我才学到了从红黑树的概念模型2-3-4树出发，理解了红黑树五大定义背后的逻辑 ，深刻认识到红黑节点颜色背后的意义，对于插入删除引发的动态变化有一定的认识，而不再是去硬性的记忆某个场景下的调平操作。
数据结构：红黑树
让我思考一下
06-02 815
红黑树 红黑树是一种自平衡二叉查找树，可以在O(log(n))O(log(n))O(log(n))时间内完成查找、插入和删除。相对于AVL树来说，牺牲了部分平衡性以换取插入/删除操作时少量的旋转操作，整体来说性能要优于AVL树。红黑树较AVL树等二叉树的不同在于其有个标识位（红色或者黑色），这个标识位的作用在于减少因不平衡造成的旋转操作，虽然此时树不是完全平衡二叉树，但依然有O(log(n)O(log(n)O(log(n)的时间效率。 红黑树的性质 红黑树要满足如下性质： Each node is eit
数据结构-红黑树（超详细，强烈推荐！！）
DChuan
01-09 1467
(一) 基本概念 Red-Black Tree 称为“红黑树”，是一种自平衡二叉查找树，红黑树和 AVL 树类似，在进行插入和删除时需要通过旋转和重新着色来维持其红黑树的特性。 红黑树的应用相当广泛，主要是用它来存储有序的数据，它的时间复杂度为 O(logn)，查询效率非常高。 1. 红黑树和 AVL 树的区别： 红黑树并不追求“完全平衡” —— 它只要求部分地达到平衡要求，降低了对旋转的要求，
【数据结构】红黑树（RBTree）详解——C++实现
Sauron7i的博客
10-15 708
每一个节点都是有颜色的，不是黑色就是红色。根节点root必须是黑色的。所有叶子节点都是黑色的，叶子节点是NULL节点，不存储实际的数据。每个红色节点必须有两个黑色的子节点，或者说是从每个叶子节点到根节点的所有路径上不能有连续的红色节点。从任一节点到其每个叶子上的所有简单路径都包含相同数目的黑色节点。因为每个节点不是红色就是黑色，所以需要定义一个颜色相关的枚举量。还需要操作其父节点，所以定义一个parent指针。private :// 节点颜色 enum Color {
Java实现数据结构——红黑树
x_k的专栏
04-19 1964
红黑树定义 相比二叉查找树，红黑树中的节点多个颜色属性。通过颜色属性，确保了从根节点到每个叶子节点的简单路径，没有一条路径超过其他路径2倍，近似于平衡。 性质： 每个节点或是红色，或是黑色 根节点是黑色 每个叶节点是黑色 如果一个节点是红色，那么它的两个子节点都是黑色 对于每个节点，从该节点到其所有后代叶节点的简单路径上，包含相同数目的黑色节点 Java代码实现中，性质3：每个叶节点为黑...
数据结构，树、二叉树、红黑树、堆、图等结构教程
03-18
"该资源是一份关于数据结构的教程，涵盖了树、二叉树、红黑树、堆和图等重要概念。教程旨在帮助学习者理解数据结构的复杂度分析，以及常见数据结构如二叉树的定义、属性、表示方式和遍历方法。" 在计算机科学中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值