红黑树代码实现

已于 2024-05-21 16:58:07 修改
阅读量47 收藏
点赞数 3
文章标签： 算法 数据结构 c++
于 2024-05-01 22:20:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HSS521314/article/details/138381033
版权 
#include<time.h>
#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>
typedef struct Balance_Tree
{
	int id;
	void* data;
	int color;
	struct Balance_Tree* parent;
	struct Balance_Tree* left;
	struct Balance_Tree* right;
}Balance_Tree;
enum RB_COLOR
{
	BLACK,
	RED
};
//创造节点
static Balance_Tree* Create_Node(int id,void*data)
{
	Balance_Tree* Node = (Balance_Tree*)malloc(sizeof(Balance_Tree));
	if (Node == NULL)
		return NULL;
	Node->id = id;
	Node->data = data;
	Node->color = RED;
	Node->parent = NULL;
	Node->left = NULL;
	Node->right = NULL;
	return Node;
}
//获取节点颜色
static inline int GetNode_Color(Balance_Tree*Node)
{
	return Node!=NULL ? Node->color : BLACK;
}
//右旋
static inline void L_L(Balance_Tree*Node_Left_Son, Balance_Tree*Node)
{
	Balance_Tree* Node_parent = Node->parent;
	Balance_Tree* Node_Left_Son_right = Node_Left_Son->right;
	Node->parent = Node_Left_Son;
	Node_Left_Son->right = Node;
	Node->left = Node_Left_Son_right;
	if (Node_Left_Son_right !=NULL)
	{
		Node_Left_Son_right->parent = Node;
	}
	if (Node_parent !=NULL)
	{
		if (Node_parent->left == Node)
			Node_parent->left = Node_Left_Son;
		else
			Node_parent->right = Node_Left_Son;
	}
	Node_Left_Son->parent = Node_parent;
}
//左旋
static inline void R_R(Balance_Tree*Node, Balance_Tree*Node_Right_Son)
{
	Balance_Tree* Node_parent = Node->parent;
	Balance_Tree* Node_Right_Son_left = Node_Right_Son->left;
	Node->parent = Node_Right_Son;
	Node_Right_Son->left = Node;
	Node->right = Node_Right_Son_left;
	if (Node_Right_Son_left !=NULL)
	{
		Node_Right_Son_left->parent = Node;
	}
	if (Node_parent !=NULL)
	{
		if (Node_parent->left == Node)
			Node_parent->left = Node_Right_Son;
		else
			Node_parent->right = Node_Right_Son;
	}
	Node_Right_Son->parent = Node_parent;
}
//调整方法
static inline void  Opt_R_B(Balance_Tree* Grand_parent, Balance_Tree* parent, Balance_Tree* Uncle)
{
	Grand_parent->color = RED;
	parent->color = BLACK;
	Uncle->color = BLACK;
}
static inline void Opt_LL(Balance_Tree* Grand_parent, Balance_Tree* parent)
{
	Grand_parent->color = RED;
	parent->color = BLACK;
	L_L(parent,Grand_parent);
}
static inline void Opt_RR(Balance_Tree* Grand_parent, Balance_Tree* parent)
{
	Grand_parent->color = RED;
	parent->color = BLACK;
	R_R(Grand_parent,parent);
}
static inline void Opt_LR(Balance_Tree* Grand_parent, Balance_Tree* parent, Balance_Tree*Node)
{
	Grand_parent->color = RED;
	R_R(parent,Node);
	Node->color = BLACK;
	L_L(Node,Grand_parent);
}
static inline void Opt_RL(Balance_Tree* Grand_parent, Balance_Tree* parent, Balance_Tree*Node)
{
	Grand_parent->color = RED;
	L_L(Node, parent);
	Node->color = BLACK;
	R_R(Grand_parent,Node);
}
//调整树节点
static Balance_Tree* Adjust_Tree(Balance_Tree*Node)
{
	Balance_Tree* parent = NULL;
	Balance_Tree* Uncle = NULL;
	Balance_Tree* Grand_parent = NULL;
	do{
	     parent = Node->parent;
		 Grand_parent = parent->parent;
		if (Grand_parent->left == parent)
			Uncle = Grand_parent->right;
		else
			Uncle = Grand_parent->left;
	//判断是否为父叔为红
	 if (GetNode_Color(Uncle)==RED)
	 {//如果是父叔双红就变黑
		 Opt_R_B(Grand_parent, parent, Uncle);
		 Node = Grand_parent;
		 if (GetNode_Color(Grand_parent->parent) == BLACK)
			 return Grand_parent;
	 }
	 else
		 break;
	}while (true);
	//进行旋转调整
	if (Grand_parent->left == parent)
	{//L
		if (parent->left == Node)
		{//L+L
			Opt_LL(Grand_parent, parent);
		    Grand_parent = parent;
		}
		else
		{//L+R
			Opt_LR(Grand_parent, parent, Node);
		    Grand_parent = Node;
		}
	}
	else
	{//R
		if (parent->right == Node)
		{//R+R
			 Opt_RR(Grand_parent, parent);
			 Grand_parent = parent;
		}
		else
		{//R+L
			Opt_RL(Grand_parent, parent, Node);
			Grand_parent = Node;
		}
	}
	return Grand_parent;
}
//增加树节点
extern bool Add_Node(Balance_Tree**Tree,int id,void *data)
{
	Balance_Tree* Add = Create_Node(id, data);
	if (Add == NULL)
		return false;
	if (*Tree==NULL)
	{
		*Tree = Add;
		(*Tree)->color = BLACK;
		return true;
	}
	Balance_Tree* Temp = *Tree;
	while (true)
	{
		if (Temp->id==id)
		{
			free(Add);
			return false;
		}
		else if (Temp->id>id)
		{
			if (Temp->left == NULL)
			{
				Temp->left = Add;
				break;
			}
			Temp = Temp->left;
		}
		else
		{
			if (Temp->right==NULL)
			{
				Temp->right = Add;
				break;
			}
			Temp = Temp->right;
		}
	}	
	Add->parent = Temp;
	//如果父亲节点是红色就触发红黑调整
	if(GetNode_Color(Temp)==RED)
	{
		Temp = Adjust_Tree(Add);
		//判断根节点是否发生变化
		if (Temp->parent == NULL)
		{
			*Tree = Temp;
			(*Tree)->color = BLACK;
		}
	}
	return true;
}
//查找树节点
extern Balance_Tree* Find_Node(Balance_Tree*Node,int id)
{
	while (Node!=NULL)
	{
		if (Node->id==id)
			return Node;		
		else if (Node->id>id)		
			Node = Node->left;		
		else	
			Node = Node->right;	
	}
	return Node;
}
static Balance_Tree* Right_Node(Balance_Tree*Node)
{
	while (Node->right != NULL)
	{
		Node = Node->right;
	}
	return Node;
}
static inline void Copy_Node(Balance_Tree*Node1,Balance_Tree*Node2)
{
	Node1->id = Node2->id;
	Node1->data = Node2->data;
}
//处理旋转的黑色节点
static Balance_Tree* Del_Exchange(Balance_Tree*parent, Balance_Tree*Uncle)
{
	if (GetNode_Color(Uncle) == RED)
	{//叔叔为红
		Balance_Tree* Temp = NULL;
		Uncle->color = BLACK;
		if (parent->left==Uncle)
		{//确定叔叔节点的位置
			Temp = Uncle->right;
			Temp->color = RED;
			L_L(Uncle,parent);
			if (GetNode_Color(Temp->left) == RED || GetNode_Color(Temp->right) == RED)
			{//判断侄子是否存在子节点
				if (GetNode_Color(Temp->left) == BLACK)
				{//判断侄子节点是否只存在一个红色节点
					R_R(Temp, Temp->right);
					Temp->color = BLACK;
					Temp = Temp->parent;
				}
				else
					Temp->left->color = BLACK;
				L_L(Temp,parent);
			}
	    }
		else
		{
			Temp = Uncle->left;
			Temp->color = RED;
			R_R(parent,Uncle);
			if (GetNode_Color(Temp->left) == RED || GetNode_Color(Temp->right) == RED)
			{//判断侄子是否存在子节点
				if (GetNode_Color(Temp->right) == BLACK)
				{//判断侄子节点是否只存在一个红色节点
					L_L(Temp->left, Temp);
					Temp->color = BLACK;
					Temp = Temp->parent;
				}
				else
					Temp->right->color = BLACK;
				R_R(parent,Temp);
			}
		}
	}
	else
	{//叔叔为黑
		int color = parent->color;//父亲节点可能为红色，记住父亲节点的颜色
		parent->color = BLACK;
		if (parent->left == Uncle)
		{//确定叔叔节点的位置
			if (GetNode_Color(Uncle->left) == BLACK)
			{//判断侄子节点是否只存在一个红色节点
				Uncle->right->color = BLACK;
				R_R(Uncle, Uncle->right);
				Uncle = parent->left;
			}
			else
				Uncle->left->color = BLACK;
			L_L(Uncle,parent);
		}
		else
		{
			if (GetNode_Color(Uncle->right) == BLACK)
			{//判断侄子节点是否只存在一个红色节点
				Uncle->left->color = BLACK;
				L_L(Uncle->left, Uncle);
				Uncle = parent->right;
			}
			else
				Uncle->right->color = BLACK;
			R_R(parent,Uncle);
		}
		//恢复父亲节点的颜色
		Uncle->color = color;
	}
	return Uncle;
}
//删除树节点
extern bool Del_Node(Balance_Tree**Node,int id)
{//对删除的各个状态进行细分处理
	Balance_Tree* Del = Find_Node(*Node,id);
	if (Del == NULL)
		return false;
	Balance_Tree* parent = NULL;
	Balance_Tree* Uncle = NULL;
	if (Del->left!=NULL&&Del->right!=NULL)
	{//双孩子
		Balance_Tree* replace = Right_Node(Del->left);
		Copy_Node(Del,replace);
		Del = replace;
	}
	if (Del->left!=NULL||Del->right!=NULL)
	{//单孩子
		Balance_Tree* replace = NULL;
		if (Del->left == NULL)
		{//判断哪个孩子不为空，不为空的孩子必为红色节点
			replace = Del->right;
			Del->right = NULL;
		}
		else
		{
			replace = Del->left;
			Del->left = NULL;
		}
		Copy_Node(Del,replace);
		parent = Del;
		Del = replace;
	}
	else
	{//没有孩子
		parent = Del->parent;
		if (parent == NULL)
		{//根节点
			*Node = NULL;
		}
		else
		{//非根节点
			if (parent->left==Del)
			{//获取叔叔节点
				Uncle = parent->right;
				parent->left = NULL;
			}
			else
			{
				Uncle = parent->left;
				parent->right = NULL;
			}
			if (GetNode_Color(Del)==BLACK)
			{//判断删除的叶节点是否为黑色节点
				Balance_Tree* Temp = NULL;
				while (GetNode_Color(parent)==BLACK&&GetNode_Color(Uncle)==BLACK&& GetNode_Color(Uncle->left)==BLACK&&GetNode_Color(Uncle->right)==BLACK)
				{//对父黑兄黑双侄黑处理颜色不需要旋转节点
					Temp = parent;
					Uncle->color = RED;
					//判断是否到达根节点
					if (parent->parent == NULL)
						return true;
					else//向上递归处理
						parent = parent->parent;
					if (parent->left == Temp)
						Uncle = parent->right;
					else
						Uncle = parent->left;
				}
				if (GetNode_Color(parent) == RED &&GetNode_Color(Uncle) == BLACK && GetNode_Color(Uncle->left) == BLACK && GetNode_Color(Uncle->right) == BLACK)
				{//对父红兄黑双侄黑处理变换不需要旋转节点
					parent->color = BLACK;
					Uncle->color = RED;
				}
				else
				{//需要节点旋转变化的节点方法
					parent = Del_Exchange(parent, Uncle);
				}
			}//如果为红色节点直接删除即可，不做任何处理
		}
	}
	free(Del);
	if (parent!=NULL&&parent->parent == NULL)
	{//判断当前的节点处理的时候是否涉及到根节点
		*Node = parent;
		parent->color = BLACK;
	}
	return true;
}
//利用后续遍历销毁树
extern void Destroy_Tree(Balance_Tree*Node)
{
	if (Node == NULL)
		return;
	Destroy_Tree(Node->left);
	Destroy_Tree(Node->right);
	free(Node);
}
extern void Find(Balance_Tree*Node)
{
	if (Node == NULL)
		return;
	Find(Node->left);
	printf(Node->color==RED?"%d   RED\n":"%d BLACK\n", Node->id);
	Find(Node->right);
}
int main()
{
	Balance_Tree* Tree = NULL;
	srand(time(NULL));
	clock_t t = clock();
	for (int i=0;i<10000000;i++)
	{
		Add_Node(&Tree,i, NULL);
    }
	printf("%dms\n",clock()-t);
	t = clock();
	for (int i = 0; i < 10000000; i++)
	{
		Del_Node(&Tree,i);
	}
	printf("%dms\n", clock() - t);
	Find(Tree);
	return 0;
}

 

 

HSS521314
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
红黑树python实现
zzp1123的博客
07-04 766
红黑树python实现
红黑树代码实现及分析2
02-25
在"红黑树代码实现及分析"这个主题中，你可以找到关于红黑树的具体实现细节，包括如何初始化树、插入和删除节点的步骤，以及如何进行颜色翻转和旋转等操作。通过分析这些代码，你可以更好地理解红黑树的工作原理，并...
java红黑树代码实现
weixin_35749796的博客
02-15 191
红黑树是一种自平衡二叉查找树，它在保持二叉查找树基本性质的同时，通过对节点进行染色，保持了树的平衡，从而保证了最坏情况下的时间复杂度为 O(log n)。 下面是一个简单的 Java 实现： ```java public class RedBlackTree<K extends Comparable, V> { private static final boolean RED ...
红黑树的原理及代码实现
qq_52093121的博客
06-28 1031
红黑树的原理这篇博文讲解的很详细了，不熟悉红黑树的定义可以看看：红黑树的详细原理讲解咱们直接进入代码实现讲解：创建一棵红黑树，先从创建红黑树的节点开始： 1.红黑树首先是一个二叉树，所以需要一个左儿子节点的指针，右儿子节点的指针 2.红黑树是有BALCK和RED两种颜色的，所以每个节点应该有颜色 3.红黑树是Key-Value存储的 4.因为之后要进行旋转等调整，所以还需要一个父节点的信息 所以红黑树节点定义如下： 2.创建红黑树整体结构 红黑树有五个性质： 为了方便整棵红黑树的维护，我们默认叶子节点是空
红黑树-Java实现
weixin_37607613的博客
04-05 9081
一、定义 红黑树是特殊的平衡二叉树，具有以下特性： 1、根节点的颜色是黑色 2、节点颜色要么是黑色、要么是红色 3、如果一个节点的颜色是红色，则它的子节点必须是黑色，即不能有2个连续的红色节点 4、每个叶子节点都是黑色(这里的叶子节点是为空的叶子节点) 5、从一个节点到该节点的叶子节点的所有路径上都包含相同数量的黑色节点 通过上面的定义，可以看到红黑树本质上还是一颗二叉查找树，所以，对红黑树的插入删除操作都可以分为两阶段来完成，首先，将红黑树看成一颗普通的二叉查找树完成插入删除操....
红黑树 图文详解与代码实现
qq_54831038的博客
09-01 1042
红黑树被应用于数据结构map/set的封装的底层，也应用于Linux的数据内核，在进程调度CFS，虚拟内存管理，共享内存slab等场景都有广泛应用。数据结构的角度看，（1）用于存储。无论数据是否平衡都可以在O（logN)的复杂度下完成 搜索、插入、删除操作。（2）用于排序。找到最小值和最大值红黑树黑色和红色 也可看成两种状态，红黑区分的状态中，可以根据实际需求添加业务逻辑。......
红黑树（C++实现）
2202_75331338的博客
07-22 988
◉ 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。◉ 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则对p先进行左单旋，回到情况二 再对g进行右单旋。p为g的右孩子，cur为p的左孩子，则对p先进行右单旋，回到情况二 再对g进行左单旋。
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
红黑树原理详解及代码实现
CodePanda@GPF的博客
05-23 2664
红黑树原理及代码实践
理解红黑树及代码实现
qq_38412637的博客
01-19 7982
1.红黑树定义 红黑树是一颗 红-黑的平衡二叉树,它具有二叉树的所有特性,是一颗自平衡的排序二叉树.(树中任何节点值都大于左子节点的值，而且都小于右子节点的值),其检索效率高，它是一颗空树或它的左右两个子树高度差的绝对值不超过1，并且左右子树都是平衡二叉树. 最坏的情况下 是一边倒的情况 在这种情况下，如果我们要在树中查找g节点，就需要顺着根节点往下找,时间复杂度约为O(n)常数级。那么红黑...
红黑树实现代码+详细注释
ltrbless的博客
05-19 1566
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
红黑树代码实现及分析
02-25
- 插入和删除操作的代码实现是红黑树的重点，需要细致地处理各种情况并保持性质不变。 - 为了保持平衡，插入和删除过程中可能需要进行旋转和重新着色，这部分代码相对复杂。 理解红黑树的概念和原理是关键，但...
红黑树的代码实现
09-19
"红黑树的代码实现" 红黑树是一种自平衡的二叉查找树，它具有良好的查找、插入和删除性能。红黑树的代码实现是使用C++语言编写的，使用模板实现，可以对任意类型的数据进行处理。 红黑树的节点结构体定义为： ```...
红黑树的实现C++代码
07-27
用C++代码实现了一个红黑树，大家可以一起学习学习，有问题也可以直接给我留言
C语言实现红黑树的实例代码
12-25
因为看内核的时候感觉红黑树挺有意思的，所以利用周末的时间来实现一下玩玩。红黑树的操作主要是插入和删除，而删除的时候需要考虑的情况更多一些。具体的操作就不在这里罗嗦了，百度文库里面有一个比较有好的文章，...
【LeetCode每日一题】——623.在二叉树中增加一行
最新发布
IronmanJay的博客
08-14 796
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
代码随想录算法训练营第十一天
b1ankwall的博客
08-10 1260
参加代码随想录第43期算法训练营day11|150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素，栈与队列总结
[算法2] 第二集 二叉树中的深度搜索
2301_80017277的博客
08-09 894
一、（DFS，全称为 Depth First Traversal），是我们树或者图这样的数据结构中常⽤的⼀种遍历算法。这个算法会尽可能深的搜索树或者图的分支，直到⼀条路径上的所有节点都被遍历完毕，然后再回溯到上⼀层，继续找⼀条路遍历。在⼆叉树中，常见的深度优先遍历为：前序遍历、中序遍历以及后序遍历。因为树的定义本⾝就是递归定义，因此采⽤递归的方法去实现树的三种遍历不仅容易理解⽽且代码很简洁。
算法：外卖调度
m0_73915763的博客
08-13 1069
有N个餐厅和M个外卖员，每个餐厅在某个时间点会产生一个外卖订单，这些订单都有产生时间、所需送达时间和优先级。外卖员在空闲时会选择最优先的订单来配送，直到所有订单都被送达。具体规则如下: 对于每个餐厅的订单，优先级高的订单优先，其次是所需送达时间最短的订单，再次是产生时间最早的订单。外卖员在空闲时会从所有餐厅的最高优先级订单中挑选一个所需送达时间最短的订单进行配送，若所需送达时间相同则选择餐厅编号最小的订单。
Java红黑树代码实现
09-08
下面是一个简单的Java红黑树代码实现示例： ```java // 定义红黑树节点 class Node { int data; // 节点数据 Node left; // 左子节点 Node right; // 右子节点 Node parent; // 父节点 boolean isRed; // 是否...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值