红黑树RBT基本概念与实现

最新推荐文章于 2024-10-17 09:31:10 发布
最新推荐文章于 2024-10-17 09:31:10 发布
阅读量774 收藏 1
点赞数 1
分类专栏： 数据结构与算法基础（c） 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39350434/article/details/108273534
版权
本文介绍了红黑树的基本概念，它作为一种优化的平衡二叉搜索树，确保查找效率。文章详细阐述了红黑树的性质，如根节点为黑色、红色节点不能相邻等，并探讨了在红黑树中添加节点的过程，说明了添加的节点默认为红色的原因。此外，还提及了节点删除的操作，讨论了在删除操作中如何维护红黑树的平衡。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. 基本概念

RBT的作用与平衡二叉树类似，目的是优化原始BST查找效率低的问题。RBT需成立，要满足如下条件：

  • 树中每个节点有颜色（红或黑）
  • 根节点必须为黑色
  • NULL值处称为终端节点，我们可以认为是黑色
  • 不允许两个红节点互为父子关系
  • 从任意节点向下出发，到所有终端节点的各条路径上黑节点个数相同

2. RBT节点添加

向RBT添加节点，该节点默认初始化为红色。（若为黑色则第五个条件不满足，若为红色可能不满足第四个条件，但第五个条件不好调控，所以选择红色。）
添加步骤如下图：
在这里插入图片描述

3. RBT节点删除

在这里插入图片描述
代码实现：

#include<stdio.h>
#include<stdlib.h>

enum COLOR{RED,BLACK};

typedef struct rbt
{
	int nValue;
	int nColor;
	struct rbt *pLeft;
	struct rbt *pRight;
	struct rbt *pFather;
}RBT;

RBT *pRBT = NULL;

void RightRotate(RBT **pTree)
{
	if(*pTree == NULL || (*pTree)->pLeft == NULL)return;

	RBT *pNode = *pTree;
	RBT *pMark = pNode->pLeft;

	//三个孩子关系
	pNode->pLeft = pMark->pRight;
	pMark->pRight = pNode;
	if(pNode->pFather != NULL)
	{
		if(pNode == pNode->pFather->pLeft)
		{
			pNode->pFather->pLeft = pMark;
		}
		else
		{
			pNode->pFather->pRight = pMark;
		}
	}
	else
	{
		//换根
		pRBT = pMark;
	}

	//三个父亲关系
	if(pNode->pLeft != NULL)
	{
		pNode->pLeft->pFather = pNode;
	}

	pMark->pFather = pNode->pFather;
	pNode->pFather = pMark;
}
void LeftRotate(RBT **pTree)
{
	if(*pTree == NULL || (*pTree)->pRight == NULL)return;

	RBT *pNode = *pTree;
	RBT *pMark = pNode->pRight;

	//三个孩子关系
	pNode->pRight = pMark->pLeft;
	pMark->pLeft = pNode;
	if(pNode->pFather != NULL)
	{
		if(pNode == pNode->pFather->pLeft)
		{
			pNode->pFather->pLeft = pMark;
		}
		else
		{
			pNode->pFather->pRight = pMark;
		}
	}
	else
	{
		//换根
		pRBT = pMark;
	}

	//三个父亲关系
	if(pNode->pRight != NULL)
	{
		pNode->pRight->pFather = pNode;
	}

	pMark->pFather = pNode->pFather;
	pNode->pFather = pMark;
}

RBT *Search(RBT *pTree,int nNum)
{
	if(pTree == NULL)return NULL;

	while(pTree)
	{
		if(pTree->nValue > nNum)
		{
			//左侧
			if(pTree->pLeft == NULL)
			{
				return pTree;
			}
			pTree = pTree->pLeft;
		}
		else if(pTree->nValue < nNum)
		{
			if(pTree->pRight == NULL)
			{
				return pTree;
			}
			pTree = pTree->pRight;
		}
		else
		{
			printf("data error.\n");
			exit(1);
		}
	}
}

RBT *GetUncle(RBT *pNode)
{
	if(pNode == pNode->pFather->pLeft)
	{
		return pNode->pFather->pRight;
	}
	else
	{
		return pNode->pFather->pLeft;
	}
}

void AddNode(RBT *pTree,int nNum)
{
	//查找
	RBT *pNode = NULL;
	pNode = Search(pTree,nNum);

	//申请空间
	RBT *pTemp = NULL;
	pTemp = (RBT*)malloc(sizeof(RBT));
	pTemp->nValue = nNum;
	pTemp->nColor = RED;
	pTemp->pFather = pNode;
	pTemp->pLeft = NULL;
	pTemp->pRight = NULL;

	//情况分析
	//1.空树
	if(pNode == NULL)
	{
		pRBT = pTemp;
		pRBT->nColor = BLACK;
		return;
	}

	//非空树
	//连接
	if(pTemp->nValue < pNode->nValue)
	{
		pNode->pLeft = pTemp;
	}
	else
	{
		pNode->pRight = pTemp;
	}
	
	//2.父亲是黑的
	if(pNode->nColor == BLACK)
	{
		return;
	}

	//3.父亲是红的
	RBT *pUncle = NULL;
	RBT *pGrandFather = NULL;
	
	while(pNode->nColor == RED)
	{
		pGrandFather = pNode->pFather;
		pUncle = GetUncle(pNode);

		//3.1叔叔是红色
		if(pUncle != NULL && pUncle->nColor == RED)
		{
			pNode->nColor = BLACK;
			pUncle->nColor = BLACK;
			pGrandFather->nColor = RED;

			pTemp = pGrandFather;
			pNode = pTemp->pFather;

			//根
			if(pNode == NULL)
			{
				pRBT->nColor = BLACK;
				break;
			}

			continue;
		}

		//3.2叔叔是黑的
		if(pUncle == NULL || pUncle->nColor == BLACK)
		{
			//3.2.1父亲是爷爷的左
			if(pNode == pGrandFather->pLeft)
			{
				//3.2.1.1当前节点是父亲的右
				if(pTemp == pNode->pRight)
				{
					pTemp = pNode;

					LeftRotate(&pTemp);

					pNode = pTemp->pFather;
				}

				//3.2.1.2当前节点是父亲的左侧
				if(pTemp == pNode->pLeft)
				{
					pNode->nColor = BLACK;
					pGrandFather->nColor = RED;

					RightRotate(&pGrandFather);
					break;
				}
			}

			//3.2.2父亲是爷爷的右
			if(pNode == pGrandFather->pRight)
			{
				//3.2.2.1当前节点是父亲的左
				if(pTemp == pNode->pLeft)
				{
					pTemp = pNode;

					RightRotate(&pTemp);

					pNode = pTemp->pFather;
				}

				//3.2.2.2当前节点是父亲的右
				if(pTemp == pNode->pRight)
				{
					pNode->nColor = BLACK;
					pGrandFather->nColor = RED;

					LeftRotate(&pGrandFather);
					break;
				}
			}
		}
	}
}

void CreateRBT(int arr[],int nLength)
{
	if(arr == NULL || nLength <= 0)return;

	int i;
	for(i = 0;i<nLength;i++)
	{
		AddNode(pRBT,arr[i]);
	}
}

void Traversal(RBT *pTree)
{
	if(pTree == NULL)return;

	printf("val == %d\tcol == %d\n",pTree->nValue,pTree->nColor);

	Traversal(pTree->pLeft);
	Traversal(pTree->pRight);
}

RBT *FindNode(RBT *pTree,int nNum)
{
	if(pTree == NULL)return NULL;

	while(pTree)
	{
		if(pTree->nValue == nNum)
		{
			return pTree;
		}
		else if(pTree->nValue > nNum)
		{
			pTree = pTree->pLeft;
		}
		else
		{
			pTree = pTree->pRight;
		}
	}

	return NULL;
}

void DelNode(RBT *pTree,int nNum)
{
	//查找
	RBT *pTemp = NULL;
	pTemp = FindNode(pTree,nNum);

	if(pTemp == NULL)return;

	//分析孩子情况
	RBT *pMark = NULL;

	if(pTemp->pLeft != NULL && pTemp->pRight != NULL)
	{
		pMark = pTemp;

		pTemp = pTemp->pLeft;
		while(pTemp->pRight != NULL)
		{
			pTemp = pTemp->pRight;
		}

		//值覆盖
		pMark->nValue = pTemp->nValue;
	}

	//颜色
	RBT *pNode = pTemp->pFather;
	//1.根 且无孩子
	if(pNode == NULL && pTemp->pLeft == NULL && pTemp->pRight == NULL)
	{
		pRBT = NULL;
		free(pTemp);
		pTemp = NULL;
		return;
	}

	//2.根 且有一个红孩子
	if(pNode == NULL && (pTemp->pLeft != NULL || pTemp->pRight != NULL))
	{
		pRBT = pTemp->pLeft ? pTemp->pLeft : pTemp->pRight;
		pRBT->nColor = BLACK;
		pRBT->pFather = NULL;

		free(pTemp);
		pTemp = NULL;
		return;
	}

	//3.非根 红色 
	if(pTemp->nColor == RED)
	{
		if(pTemp == pNode->pLeft)
		{
			pNode->pLeft = NULL;
		}
		else
		{
			pNode->pRight = NULL;
		}
		free(pTemp);
		pTemp = NULL;
		return;
	}

	//4.非根 黑色 且有一个红孩子
	if(pTemp->nColor == BLACK && (pTemp->pLeft != NULL || pTemp->pRight != NULL))
	{
		if(pTemp == pNode->pLeft)
		{
			pNode->pLeft = pTemp->pLeft ? pTemp->pLeft:pTemp->pRight;
			pNode->pLeft->pFather = pNode;
			pNode->pLeft->nColor = BLACK;
		}
		else
		{
			pNode->pRight = pTemp->pLeft ? pTemp->pLeft:pTemp->pRight;
			pNode->pRight->pFather = pNode;
			pNode->pRight->nColor = BLACK;
		}

		free(pTemp);
		pTemp = NULL;
		return;
	}

	//5.非根 黑 且无孩子
	RBT *pBrother = GetUncle(pTemp);
	
	//假删除
	if(pTemp == pNode->pLeft)
	{
		pNode->pLeft = NULL;
	}
	else
	{
		pNode->pRight = NULL;
	}

	pMark = pTemp;

	while(1)
	{
		//5.1兄弟是红的
		if(pBrother->nColor == RED)
		{
			pBrother->nColor = BLACK;
			pNode->nColor = RED;

			//5.1.1兄弟是父亲的左
			if(pBrother == pNode->pLeft)
			{
				RightRotate(&pNode);
				pBrother = pNode->pLeft;
				continue;
			}

			//5.1.2兄弟是父亲的右
			if(pBrother == pNode->pRight)
			{
				LeftRotate(&pNode);
				pBrother = pNode->pRight;
				continue;
			}
		}

		//5.2兄弟是黑的
		if(pBrother->nColor == BLACK)
		{
			//5.2.1两个侄子全黑
			if((pBrother->pLeft == NULL && pBrother->pRight == NULL)||
				((pBrother->pLeft != NULL && pBrother->pLeft->nColor == BLACK)&&
				(pBrother->pRight != NULL && pBrother->pRight->nColor == BLACK)))
			{
				//5.2.1.1父亲是红的
				if(pNode->nColor == RED)
				{
					pNode->nColor = BLACK;
					pBrother->nColor = RED;
					break;
				}

				//5.2.1.2父亲是黑色的
				if(pNode->nColor == BLACK)
				{
					pBrother->nColor = RED;

					pTemp = pNode;
					pNode = pTemp->pFather;

					//根
					if(pNode == NULL)
					{
						break;
					}
					pBrother = GetUncle(pTemp);
					continue;
				}
			}

			//5.2.2左侄子红，右侄子黑
			if((pBrother->pLeft != NULL && pBrother->pLeft->nColor == RED)&&
				(pBrother->pRight == NULL || pBrother->pRight->nColor == BLACK))
			{
				//5.2.2.1兄弟是父亲的右
				if(pBrother == pNode->pRight)
				{
					pBrother->nColor = RED;
					pBrother->pLeft->nColor = BLACK;

					RightRotate(&pBrother);
					pBrother = pNode->pRight;
					continue;
				}

				//5.2.2.2兄弟是父亲的左
				if(pBrother == pNode->pLeft)
				{
					pBrother->nColor = pNode->nColor;
					pNode->nColor = BLACK;
					pBrother->pLeft->nColor = BLACK;

					RightRotate(&pNode);
					break;
				}
			}

			//5.2.3右侄子是红
			if(pBrother->pRight != NULL && pBrother->pRight->nColor == RED)
			{
				//5.2.3.1兄弟是父亲的左
				if(pBrother == pNode->pLeft)
				{
					pBrother->nColor = RED;
					pBrother->pRight->nColor = BLACK;

					LeftRotate(&pBrother);
					pBrother = pNode->pLeft;
					continue;
				}

				//5.2.3.2兄弟是父亲的右
				if(pBrother == pNode->pRight)
				{
					pBrother->nColor = pNode->nColor;
					pNode->nColor = BLACK;
					pBrother->pRight->nColor = BLACK;

					LeftRotate(&pNode);
					break;
				}
			}
		}
	}
	free(pMark);
	pMark = NULL;
}

int main()
{
	int arr[] = {11,2,14,1,7,15,5,8};
	CreateRBT(arr,sizeof(arr)/sizeof(arr[0]));
	Traversal(pRBT);
	printf("---------------------------\n");
	//AddNode(pRBT,4);
	//Traversal(pRBT);
	DelNode(pRBT,1);
	Traversal(pRBT);
	printf("---------------------------\n");
	DelNode(pRBT,11);
	Traversal(pRBT);
	printf("---------------------------\n");
	DelNode(pRBT,15);
	Traversal(pRBT);
	printf("---------------------------\n");
	DelNode(pRBT,2);
	Traversal(pRBT);
	printf("---------------------------\n");

	return 0;
}
基于风险的测试方法（RBT）
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
12-10 4474
基于风险的测试方法（RBT） 基于风险的测试是根据影响的大小和失败的可能性，对被测应用程序的特性、模块和功能进行优先级排序。它涉及基于复杂性、业务关键性、使用频率、可见区域、缺陷易发区域等来评估风险。 风险是对项目的可测量的成功标准有积极或消极影响的不确定事件的发生。可能是过去发生的事件，也可能是现在的事件，或者是将来可能发生的事情。 这些不确定事件会对项目的成本、业务、技术和质量目标产生影...
C++中红黑树的实现
最新发布
CSQCSQCC的博客
10-26 1382
/如果为空树，插入的节点作为根//根必须为黑色//找到空位置else//插入节点//插入一个红色的节点else//如果出现连续的红色节点进入下列循环if (parent == grandfather->_left) //如果叔叔节点在右边//变色//继续向上更新else //叔叔不存在或者存在且为黑色if (cur == parent->_left) //插入到p的左边。
红黑树(RBT)
YYMCR7的博客
11-05 1122
一、红黑树的相关概念 RBT就是二叉排序树的一种优化(满足基本的左子树结点值≤根结点值≤右子树结点值) RBT满足的要求:左根右，根叶黑，不红红，黑路同 具体含义： 代码定义： 【概念】结点的黑高BH：从某结点出发(不含该结点)到达任一空结点的路径上黑结点总数 如： 性质： 二、红黑树的查找 与BST、AVL相同，从根出发，左小右大，若查找到一个空叶结点，则查找失败 三、红黑树的插入 ...
数据结构中常见的树（BST二叉搜索树、AVL平衡二叉树、RBT红黑树、B-树、B+树、B*树）
热门推荐
Sup_Heaven的专栏
09-16 6万+
BST树        即二叉搜索树：        1.所有非叶子结点至多拥有两个儿子（Left和Right）；        2.所有结点存储一个关键字；        3.非叶子结点的左指针指向小于其关键字的子树，右指针指向大于其关键字的子树；        如：                B树的搜索，从根结点开始，如果查询的关键字与结点
关于红黑树（RBT）
Ybt_c_index的博客
12-22 414
本文内容主要是在看完wiki后写的，所以可以直接在wiki中找到关于红黑树的讲解，传送。 这里不罗嗦了，直接开始。 首先，红黑树是一个满足如下属性的二叉查找树（不知道二叉查找树的朋友先去补一下相关知识）： 每个节点非黑即红。 根节点为黑。有时可忽略这条规则，因为根节点总是可以由红变黑，但反过来可未必如此，这条规则的影响非常小。 所有叶子节点（NIL）都为黑。叶子节点无值。 如果一个节点为红，则它...
树（七）：红黑树(RBT) C++实现
Worthy_Wang的博客
02-23 843
文章目录
【数据结构】红黑树 的介绍及模拟实现
宫瑞阳的博客
03-01 597
红黑树 的介绍及模拟实现
【C++】红黑树
春风不语。
10-17 1549
本篇内容到这里就结束了，主要讲了红黑树的定义以及插入接口的实现逻辑，希望对大家有所帮助，祝生活愉快，下篇再见！
07-7.3.3 红黑树（RBT）
G2Esports_NiKo的博客
07-10 1339
红黑树是二叉排序树与普通二叉排序树相比，有什么要求？每个节点或是红色，或是黑色的根结点是黑色的叶子结点（外部结点、NULL结点、失败结点）均是黑色的不存在两个相邻的红结点（即红结点的父结点和孩子结点均是黑色）对每个结点，从该结点到任一叶子结点的简单路径上，所含黑结点的数目相同srtuct RBnode{ // 红黑树的结点定义int key;// 关键字的值// 父结点指针// 左孩子指针// 右孩子指针int color;
【干货分享】红黑树硬核讲解
Linuxhus的博客
06-27 339
预防针：红黑树本来就是基本算法中的难点，所以看此文时建议先有点预备心理或知识铺垫，没接触过RBT而直接看此文的话，绝对懵逼。为了数据的查询跟增删方便，系统引入了二叉查找树，它具有左节点 < 根节点 .........
数据结构（二）、红黑树（RBT）
王义凯 的博客
07-30 935
红黑树是一种自平衡的二叉树，在插入和删除操作时可能会打破树的平衡，它会重新自处理以达到平衡状态。红黑树是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(logn)时间内做查找，插入和删除，这里的n是树中元素的数目。
数据结构之二叉平衡搜索树（RBT）
OAH`Zero
07-14 209
package datastruct.binarytree; import java.util.Comparator; import java.util.Objects; public class RBTree<E> { private static class Node<E>{ boolean color; E item; Node<E> parent; Node<E> left;
红黑树RBT的原理分析及实现
Myd
07-10 970
  上一篇文章讲了 AVL 树是自平衡的二叉搜索树；在 add 和 remove 之后是通过节点的左右子节点高度差来判断调节节点的平衡；红黑树RBT，也是自平衡的二叉搜索树；RBT是通过下列条件来约束节点实现的平衡：  RBT的叶子节点  连续红色节点   这是一颗红黑树，可以观察到任意一个节点到叶子节点的路径上黑色的节点数都是相等的；比如 根节点500到叶子节点的路径一共10条；这10条路径上每一条路径的黑色节点数都是都是3个；再比如 200节点到叶子节点的路径有4条，这4条路径从叶子到200节点的黑色
红黑树RBT的（C++）实现
liuchenjane的博客
11-19 852
//RBT--红黑树 //红黑树是“平衡”搜索树的一种 //红黑树满足下面的性质： //1.每个节点或是红色或是黑色 //2.根节点是黑色的 //3.每个叶节点(NIL) 是黑色的 //4.如果一个节点是红色的，则它的两个子节点都是黑色的 //5.对每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点 #include using namespace std; class
红黑树rbt
duanmy的博客
06-25 169
red black tree，简称rbt 搜索： 顺序搜索、线性搜索，O(n) 二分搜索：排序，中点，左/右，中点，左/右…，O(log2 n) 但是，插入和删除需要移动大量元素 二叉查找树 binary search tree，bst 查找效率高，插入删除效率高 二叉树 + 左所有<节点<右所有 ...
RBT三大最佳实践（基于需求的测试）
企业级UML2建模工具、MDA工具、数据库建模工具、需求管理工具、集成开发平台
04-11 1568
RBT三大最佳实践 1、  Test early and often.尽早测试，频繁地测试 尽早的测试可以最快确认需求的业务价值。我们都知道，一个业务的需求并不是在项目启动前一次搞定的，特别是那些复杂的业务、创新的业务。实际上，需求是贯穿在项目整个生命周期中的。需求制定一方提出：我们需要什么？而软件开发一方则提出：我们能构建什么？在项目进展过程中两方对话的质量和结果是帮助决定产品的最终
Risk and RBT(风险及基于需求的测试)
软件质量优化
08-09 3718
Risk and RBT(风险及基于需求的测试)陈能技2007-8-9原文：Risk and Requirements-Based Testing （James Bach） I think we need to break out of the mythology that testing is some kind of robotic process.我想我们需要
数据结构——5红黑树(RBT)
小小魔姬
03-06 610
实现简单的红黑树(RBT) 在实现二叉搜索树(AVL)的基础上增加红黑平衡旋转 性质： 1、根节点是黑色 2、插入节点是红的 3、红色节点的子节点是黑的 4、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点 结构体Node：左结点left、右结点right、数据data、颜色col 类RBT：根结点root 主要功能有：规则判断（红黑平衡旋转）、添加、删除、查询、遍历(前序遍历、中序遍历、...
常说的风险评估，那么「基于风险的测试 （RBT）」如何测试？
NHB222222的博客
10-12 1188
基于风险的测试 （RBT） 是一种，它根据风险的概率和影响确定测试活动的优先级。它涉及在潜在问题发生之前识别它们，并将资源分配给风险最高的测试区域。在 RBT 中，“风险”是指缺陷的可能性及其对系统运行或业务的潜在后果。若要实现 RBT，团队通常遵循以下步骤：识别潜在风险。根据这些风险的严重性和可能性来评估这些风险并确定其优先级。定义和目标，以降低最高风险。相应地分配测试资源。执行测试，首先关注最关键的领域。根据需要监控和调整。
JDK源码解析：红黑树TreeMap深度剖析
内容包括红黑树的基本概念、性质、删除操作的几种情况，以及与其他数据结构如AVL树的对比。课程还涉及了源码剖析、算法理论、LeetCode/LintCode实战和面试题解答，要求学习者具备扎实的Java基础和数据结构与算法知识...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值