算法导论-----红黑树

最新推荐文章于 2024-06-24 10:08:14 发布
最新推荐文章于 2024-06-24 10:08:14 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： C++ 文章标签： Algorithm 算法导论 c++ 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anhuizhuanjiao/article/details/8976245
版权 
/*
红黑树的性质：
1、每个结点或是红色，或是黑色
2、根结点是黑色
3、如果一个结点是红色，则它的两个子结点都是黑色
4、对每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
5、所有叶子结点都是黑色
*/
#include "iostream"
using namespace std;

typedef enum  node_color
{
	BLACK,
	RED
}NODECOLOR;
typedef struct Node
{
	int    value;
	struct Node* parent;
	struct Node* left;
	struct Node* right;
	NODECOLOR    color;
}NODE,*NODE_POINT;


class  Tree
{
private:

	NODE_POINT     root;
	NODE_POINT*    EMPTY;
	void LEFT_ROTATE(NODE_POINT   x);
	void RIGHT_ROTATE(NODE_POINT  y);
	//插入时保持红黑性质
	void RB_INSERT_FIXUP(NODE_POINT z);
	//替换过程
	void RB_TRANSPLANT(NODE_POINT u,NODE_POINT v);
	//删除时保持红黑性质
	void RB_DELETE_FIXUP(NODE_POINT  x);
	//删除所有结点
	void  DELETE_ALL_NODE(NODE_POINT node);
public:
	Tree();
	~Tree();
	NODE_POINT  MINIMUM(NODE_POINT x);
	NODE_POINT  MAXIMUM(NODE_POINT x);
	NODE_POINT  MAXIMUM();
	NODE_POINT  MINIMUM();
	NODE_POINT  SEARCH(NODE_POINT x,int k);
	NODE_POINT  SEARCH(int k);
	NODE_POINT  SUCCESSOR(NODE_POINT node);
	void  INSERT_NODE(int  x);
	void  DELETE_NODE(int  x);
	
};

void Tree::DELETE_ALL_NODE(NODE_POINT node)
{
	if(node!=NULL)
	{
		DELETE_ALL_NODE(node->left);
		if(node->right!=NULL)
		{
			DELETE_ALL_NODE(node->right);
		}
		free(node);
		node=NULL;
	}
}
Tree::~Tree()
{
	DELETE_ALL_NODE(root);
}
Tree::Tree():root(NULL),EMPTY(NULL)
{
	EMPTY=(NODE_POINT*)malloc(sizeof(NODE));
	*EMPTY=NULL;
}

NODE_POINT Tree::MAXIMUM()
{
	return MAXIMUM(root);
}

NODE_POINT Tree::MINIMUM()
{
	return MINIMUM(root);
}
void Tree::RB_DELETE_FIXUP(NODE_POINT x)
{
	while (x!=root&&x->color==BLACK)
	{
		if(x==x->parent->left)
		{
				/*
				当x为其父结点的左孩子时，删除结点会有以下四种情况
				1、x的兄弟结点node是红色
				2、x的兄弟结点node是黑色，而且node的两个子结点都是黑色
				3、x的兄弟结点node是黑色，node的左孩子是红色,node的右孩子是黑色
				4、x的兄弟结点node是黑色,且node的右孩子是红色

				x是取代要删除的结点的结点,当x为其父结点的右孩子时，情况类似(颠倒左右)
				*/
			NODE_POINT  node=x->parent->right;
			//情况1，左旋可转变为情况2、3、4
			if(node->color==RED)
			{
				node->color=BLACK;
				x->parent->color=RED;
				LEFT_ROTATE(x->parent);
				node=x->parent->right;
			}

			
			if(node->left==NULL)
			{
				//情况2
				if(node->right==NULL||node->right->color==BLACK)
				{
					node->color=RED;
				//	RIGHT_ROTATE(node);
					x=x->parent;//
				}
			}
			else
			{
				//情况2
				if(node->right==NULL)
				{
					if(node->left->color==BLACK)
					{
						node->color=RED;
					//	RIGHT_ROTATE(node);
						x=x->parent;//
					}
				}
				//情况2
				else if(node->right->color==BLACK&&node->left->color==BLACK)
				{
					node->color=RED;
				//	RIGHT_ROTATE(node);
					x=x->parent;//
				}
				else
				{
					//情况3，可右旋变为情况4
					if(node->right->color==BLACK)
					{
						node->left->color=BLACK;
						node->color=RED;
						RIGHT_ROTATE(node);
						node=x->parent->right;
					}

					//情况4
					node->color=x->parent->color;
					x->parent->color=BLACK;
					LEFT_ROTATE(x->parent);

					x=root;
				}
			}
		}
		else
		{
			NODE_POINT  node=x->parent->left;
			//情况1，右旋可转变为情况2、3、4
			if(node->color==RED)
			{
				node->color=BLACK;
				x->parent->color=RED;
				RIGHT_ROTATE(x->parent);
				node=x->parent->right;
			}

			if(node->left==NULL)
			{
				//情况2
				if(node->right==NULL||node->right->color==BLACK)
				{
					node->color=RED;
				//	RIGHT_ROTATE(node);
					x=x->parent;//
				}
			}
			else
			{
				//情况2
				if(node->right==NULL)
				{
					if(node->left->color==BLACK)
					{
						node->color=RED;
				//		RIGHT_ROTATE(node);
						x=x->parent;//
					}
				}
				//情况2
				else if(node->right->color==BLACK&&node->left->color==BLACK)
				{
					node->color=RED;
				//	RIGHT_ROTATE(node);
					x=x->parent;//
				}
				else
				{
					//情况3，左旋变为情况4
					if(node->left->color==BLACK)
					{
						node->right->color=BLACK;
						node->color=RED;
						LEFT_ROTATE(node);
						node=x->parent->right;
					}

					//情况4，右旋
					node->color=x->parent->color;
					x->parent->color=BLACK;
					RIGHT_ROTATE(x->parent);

					x=root;
				}
			}
		}
	}
	x->color=BLACK;
}

void Tree::RB_TRANSPLANT(NODE_POINT u,NODE_POINT v)
{
	if(u->parent==NULL)
	{
		root=v;
	}
	else if(u==u->parent->left)
	{
		u->parent->left=v;
	}
	else
	{
		u->parent->right=v;
	}
	if(v!=NULL)
		v->parent=u->parent;
}
void Tree::DELETE_NODE(int k)
{
	NODE_POINT z,y,x;
	z=SEARCH(k);
	if(z==NULL)
	{
		printf("此红黑树中不存在该结点\n");
		return ;
	}
	else
	{
		y=z;
		//用来保存y的颜色
		NODECOLOR  color;
		color=y->color;
		if(z->left==NULL)
		{
			x=z->right;
			if(x==NULL)
			{
				//判断z是否为根结点
				if(z->parent==NULL)
				{
					free(root);
					root=NULL;
					z=NULL;
					return ;
				}
				else if(z==z->parent->right)
				{
					z->parent->right=NULL;
					z->parent=NULL;
					free(z);
					z=NULL;
				}
				else
				{
					z->parent->left=NULL;
					z->parent=NULL;
					free(z);
					z=NULL;
				}
				return;
			}
			RB_TRANSPLANT(z,x);
		}
		else if(z->right==NULL)
		{
			x=z->left;

			RB_TRANSPLANT(z,x);
		}
		else
		{
			//寻找z的后继结点
			y=SUCCESSOR(z);
			color=y->color;
			
			//如果y没有右孩子，说明它是叶结点,直接替换z就OK
			if(y->right==NULL)
			{
				if(y->parent!=z)
				{
					//用NULL代替y的位置
					RB_TRANSPLANT(y,NULL);
					
					y->right=z->right;
					y->right->parent=y;
				}
				RB_TRANSPLANT(z,y);
				y->left=z->left;
				y->left->parent=y;
				y->color=z->color;

				//删除z，释放空间
				z->left=NULL;
				z->right=NULL;
				z->parent=NULL;
				free(z);
				z=NULL;

				return ;

			}
			else
			{
				x=y->right;
			}
			
			if(y->parent==z)
			{
				x->parent=y;
			}
			else
			{
				RB_TRANSPLANT(y,x);
				y->right=z->right;
				y->right->parent=y;
			}
			RB_TRANSPLANT(z,y);
			y->left=z->left;
			y->left->parent=y;
			y->color=z->color;
		}

		if(color==BLACK)
			RB_DELETE_FIXUP(x);
	}

	if(*EMPTY)
	{
		delete *EMPTY;
		if(*EMPTY==root)
		{
			root=NULL;
		}
		*EMPTY=NULL;
	}

	z->left=NULL;
	z->right=NULL;
	z->parent=NULL;
	free(z);
	z=NULL;

}

void Tree::RB_INSERT_FIXUP(NODE_POINT z)
{
	if(z->parent!=NULL)
	{
		NODE_POINT   y;
		while(z!=root&&z->parent->color==RED)
		{
			if(z->parent==z->parent->parent->left)
			{
				if(root->right==NULL)
				{
					//如果z为其父结点的左孩子，则将原根结点变为它的右兄弟
					if(z==z->parent->left)
					{
						root=z->parent;
						z->parent->right=z->parent->parent;
						z->parent->right->parent=z->parent;
						z->parent->parent=NULL;
						z->parent->right->left=NULL;
						z->parent->right->color=RED;
						root->color=BLACK;

						return;
					}
					else
					{
						//如果z为其父结点的右孩子，将z变为根结点
						root=z;
						z->right=z->parent->parent;
						z->right->parent=z;
						z->right->left=NULL;
						z->right->color=RED;

						z->left=z->parent;
						z->left->parent=z;
						z->left->right=NULL;


						root->color=BLACK;

						return;
					}
				}
				
				y=z->parent->parent->right;

				/*
				此时会有三种情况：
				1、z的叔结点y是红色
				2、z的叔结点y是黑色，且z是一个右孩子
				3、z的叔结点y是黑色，且z是一个左孩子

				情况1可转变成情况2、3
				情况2可转变成情况3

				当x的父结点是x的祖父结点的右孩子时，情况类似(左右颠倒)
				*/
		
				//情况1，可转变成情况2或3
				if(y!=NULL&& y->color==RED)
				{
					z->parent->color=BLACK;
					y->color=BLACK;
					z->parent->parent->color=RED;
					z=z->parent->parent;
				}
				else
				{
					//情况2，可转变成情况3
					if(z==z->parent->right)
					{
						//z上移一层
						z=z->parent;
						//z左旋转，会下降一层
						LEFT_ROTATE(z);
					}

					//情况3
					//修正对性质3的违反，会破坏性质4
					z->parent->color=BLACK;
					z->parent->parent->color=RED;
					//保持性质4
					RIGHT_ROTATE(z->parent->parent);
				}
			}
			else
			{
				if(root->left==NULL)
				{
					//z为其父结点的右孩子，则原根结点为它的左兄弟
					if(z==z->parent->right)
					{
						root=z->parent;
						z->parent->left=z->parent->parent;
						z->parent->left->parent=z->parent;
						z->parent->parent=NULL;
						z->parent->left->right=NULL;
						z->parent->right->color=RED;
						root->color=BLACK;

						return;
					}
					else
					{
						//如果z为其父结点的左孩子，将z变为根结点
						root=z;
						z->left=z->parent->parent;
						z->left->parent=z;
						z->left->right=NULL;
						z->left->color=RED;

						z->right=z->parent;
						z->right->parent=z;
						z->right->left=NULL;

						root->color=BLACK;

						return;
					}
				}

				y=z->parent->parent->left;
				if(y!=NULL&&y->color==RED)
				{
					z->parent->color=BLACK;
					y->color=BLACK;
					z->parent->parent->color=RED;
					z=z->parent->parent;
				}
				else
				{
					if(z==z->parent->left)
					{
						z=z->parent;
						RIGHT_ROTATE(z);
					}
					z->parent->color=BLACK;
					z->parent->parent->color=RED;
					LEFT_ROTATE(z->parent->parent);
				}
			}
		}
	}
	root->color=BLACK;
}

void Tree::INSERT_NODE(int k)
{
	//树为空,插入的为根节点
	if(root==NULL)
	{
		root=(NODE_POINT)malloc(sizeof(NODE));

		root->value=k;
		root->parent=NULL;
		root->left=NULL;
		root->right=NULL;
		root->color=BLACK;
	}
	else
	{
		NODE_POINT  z;
		NODE_POINT  x,y;
		z=(NODE_POINT)malloc(sizeof(NODE));
		z->value=k;
		x=root;
		y=NULL;

		while(x!=NULL)
		{
			y=x;
			if(z->value<x->value)
			{
				x=x->left;
			}
			else
			{
				x=x->right;
			}
		}
		z->parent=y;

		if(y==NULL)
		{
			root=z;
		}
		else if(z->value<y->value)
		{
			y->left=z;
		}
		else
		{
			y->right=z;
		}

		z->left=NULL;
		z->right=NULL;
		z->color=RED;

		RB_INSERT_FIXUP(z);
	}
}

void Tree::RIGHT_ROTATE(NODE_POINT y)
{
	if(y->parent!=NULL)
	{
		NODE_POINT x;
		x=y->left;
		y->left=x->right;

		if(x->right!=NULL)
		{
			x->right->parent=y;
		}
		x->parent=y->parent;
		if(y->parent==NULL)
		{
			root=x;
		}
		else if(y==y->parent->left)
		{
			y->parent->left=x;
		}
		else
		{
			y->parent->right=x;
		}
		x->right=y;
		y->parent=x;
	}

}

void Tree::LEFT_ROTATE(NODE_POINT x)
{
	if(x->parent!=NULL)
	{
		NODE_POINT  y;
		y=x->right;
		x->right=y->left;

		if(y->left!=NULL)
		{
			y->left->parent=x;
		}
		y->parent=x->parent;

		//x为根结点情况
		if(x->parent==NULL)
		{
			root=y;
		}
		else if(x==x->parent->left)
		{
			x->parent->left=y;
		}
		else
		{
			x->parent->right=y;
		}

		y->left=x;
		x->parent=y;
	}
}


NODE_POINT Tree::SUCCESSOR(NODE_POINT  x)
{
	//右孩子不为空
	if(x->right!=NULL)
	{
		return MINIMUM(x->right);
	}
	else
	{
		NODE_POINT y;
		y=x->parent;
		//右孩子为空,且自身为父节点右孩子
		//(当为左孩子时,父节点为其后继节点,直接返回父节点)
		while(y!=NULL&&x==y->right)
		{
			//当x位于根节点的右子树中,y最终为NULL
			x=y;
			y=y->parent;
		}      


		return  y;
	}
}

NODE_POINT Tree::SEARCH(int k)
{
	return SEARCH(root,k);
}

NODE_POINT Tree::SEARCH(NODE_POINT x,int k)
{

	if(x==NULL||k==x->value)
	{
		return x;
	}
	if(k<(x->value))
	{
		return SEARCH(x->left,k);
	}
	else
	{ 
		return SEARCH(x->right,k);
	}
}


NODE_POINT   Tree::MINIMUM(NODE_POINT  x)
{
	if(x!=NULL)
	{
		while(x->left!=NULL)
		{
			x=x->left;
		}

	}

	return x;
}

NODE_POINT  Tree::MAXIMUM(NODE_POINT  x)
{


	if(x!=NULL)
	{
		while(x->right!=NULL)
		{
			x=x->right;
		}
	}

	return x;
}

转角天边
关注
专栏目录
算法导论 - 基于 C# 的红黑树实现
东城十三
06-24 321
红黑树（Red-Black Tree）是一种自平衡二叉搜索树，它在插入和删除节点时通过重新着色和旋转保持树的平衡，从而保证查找、插入和删除操作的时间复杂度为Olog⁡nO(\log n)Ologn。本文介绍了如何在C#中实现红黑树，并提供插入、查找和删除操作的详细代码实现。set;set;set;set;set;set;Key = key;
[算法导论笔记]--红黑树
Alfeim的博客
04-27 264
一.什么是红黑树 红黑树是一棵二叉搜索树，其在每个结点上增加了一个存储位来表示颜色，可以是红(red)或者黑(black)。通过任何一条从"根到叶子的简单路径"上的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似于平衡的。红黑树是一种平衡二叉树。 红黑树的基本性质 (1)每个结点要么是红色的，要么是黑色的(废话..) (2)根结点是黑色的 (3)叶子结点是黑色的(也可...
算法导论-第13章-红黑树
CSDN博客
05-21 282
第12章介绍了一棵高度为h的二叉搜索树，它可以支持任何一种基本动态集合操作，如SEARCHSUCCESSORMINIMUMMAXIMUMINSERT和DELETE等，其时间复杂度均为Oh。因此，如果搜素树的高度较低时，这些操作会执行的较快。然而，如果树的高度较高时，这些操作可能不比在链表上执行得快。（red-black tree）是“平衡”搜索树的一种，可以保证在最坏情况下基本动态集合操作得时间复杂度为Ologn。
算法导论--红黑树
勿在浮砂筑高台
05-17 5379
红黑树是平衡搜索树的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为Lgn。红黑树在二叉搜索树的基础上结点增加了一个属性color，值为black或者red,即一个节点的属性有：left,right,p,color,key。同时，红黑树使用一个哨兵T_NIL代替以一般搜索树中的NULL,T_NIL也是一个普通的结点，也具有以上5个属性，它的color属性为black,其他属性为任意值。即叶子结点的左右孩子全部指向哨兵，以及根节点的父指针也指向哨兵。
算法导论06--红黑树构建算法
张嘉睿的博客
11-12 1084
一、目的 1．熟悉算法设计的基本思想 2．掌握构建红黑树的方法 二、内容与设计思想 编写随机整数生成算法，生成S到T范围内的N个随机整数并输出； 编写红黑树构建算法，中序遍历各节点，输出颜色和值； 随机生成1e2、1e3、1e4、1e5、1e6个不同的数，使用红黑树构建算法，并画图描述不同情况下的运行时间差异； 三、使用环境 推荐使用C/C++集成编译环境。 四、实验过程 1、写出红黑树构建算法的源代码 #include<bits/stdc++.h> using namespace std;
算法导论-红黑树基本概念
hxlove123456的博客
07-24 910
刚刚接触到红黑树的时候，感觉很奇怪，二叉树已经很好用了，为什么要发明红黑树？？看到算法导论的目录才明白，二叉树在执行查找，删除操作的时候，时间复杂度为O（h）,这时间复杂度与二叉树的高度有关，如果二叉树高度较小，自然很方便，但是如果遇到树的高度较高时（所有的数据都在一根树枝上），二叉树和链表就差别不大了。所以发明了红黑树，红黑树是一种平衡搜索树，红黑树的高度最多为2lg(n+1)，时间复杂度为O（
算法导论-基于 C# 的红黑树扩展数据结构实现
最新发布
东城十三
06-24 330
红黑树（Red-Black Tree）是一种自平衡二叉搜索树，通过重新着色和旋转操作，在插入和删除节点时保持平衡，从而保证查找、插入和删除操作的时间复杂度为Olog⁡nO(\log n)Ologn。本技术文档详细介绍了如何在C#中实现红黑树，并扩展其功能以支持更多操作。set;set;set;set;set;set;Key = key;if(uncle!
算法导论---红黑树删除详解
tang_jin2015的专栏
01-26 1561
红黑树删除算法详解 删除算法相较于插入要稍微复杂些。 删除操作，首先与二叉树删除一致，找到删除的节点，若是只有左节点或者只有右节点或者没有左右子树，那么删除的节点就是原来的节点，只要将删除节点的父节点指针指向子节点。 2）若是同时有左右子树，利用查找后继，就是找到右子树中最小的元素，然后将找到节点与这个节点的值进行交换，那么删除的就是这个后继节点，这个后继节点是基于中序遍历找出来的。 3）
算法导论-9.红黑树习题
dayuan5183的博客
01-16 1487
这一篇解决《算法导论》中红黑树章节的部分习题，在上一篇自己亲自实现红黑树后，解决这些题目就轻松多了。 练习13.1-6 在一棵黑高度为 $k$ 的红黑树中，内节点最多有多少个？最少有多少个？ 黑高度为 $k$ 的二叉树，全高度最小为 $k+1$，最大为 $2k+2$ 。内节点最多有 $2^{k+1}-1$ 个，这种情况下红黑树中没有红节点，黑节点全满（满足所有叶子节点黑高度一致的条件...
C++类的操作总结
转角万里路的专栏
11-09 1036
/*待解决问题 双目操作符的重载与单目操作符的重载问题还要继续探究类的继承，虚函数，纯虚函数 */ #include #include using namespace std; class person; //定义person类的友元函数 class people { public : people(){cout<<"People构造函数被调用"<<endl;} void pse
算法导论-----最大子数组问题（线性解法）
转角万里路的专栏
05-26 955
int _tmain(int argc, _TCHAR* argv[]) { int sum=0; int left=0; int right=0; int max=0; int A[]={13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22}; //不包含数组里全是负数的情况 for(int i=0;i<sizeof(A)/sizeof(A[0])
利用ODBC连接数据库
转角万里路的专栏
12-08 766
例子用到的数据库是MySql 添加数据源 创建MFC 基佬于对话框的工程ODBC 在工程里添加头文件 #include "afxdb.h" 创建CDatabase类的对象 CDatabase db; 接下来就是连接数据库了，在OnInitDialog函数里添加 //判断数据库是否打开 if(!db.IsOpen()) { //连接数
算法导论-----归并排序
转角万里路的专栏
05-26 751
void Merge(int *A,int p,int q,int r) { int n1=q-p+1; int n2=r-q; int *L=new int[n1]; int *R=new int[n2]; for(int i=0;i<=n1-1;++i) { L[i]=A[p+i]; } for(int j=
背包问题
转角万里路的专栏
03-28 719
问题描述：有n个物体，重为w[0],w[1]...,有一个背包，只能装重为s的物体．问背包应装入哪些 物体，使重量刚好为s。 这是很经典的一个问题，现给出两种解法，递归和非递归，递归方式是在网上下载的，非递归方式是自己写的 递归方式 #include using namespace std; int knap (int s, int n, int w[]) {
算法导论-----栈
转角万里路的专栏
05-26 680
#include using namespace std; template class Stack { private: //定义一个双向链表 typedef struct DoubleLink { T value; DoubleLink* next; DoubleLink* prev; }DOUBLE_LINK,*DOUBLE_LINK_POI
算法导论-----二叉搜索树
转角万里路的专栏
05-26 672
#include using namespace std; typedef struct Node { int value; struct Node * parent; struct Node * right; struct Node * left; }NODE,*NODE_POINT; class Tree { private: //根节点 NODE_POI
算法导论-----图（深度优先搜索）
转角万里路的专栏
06-01 667
尝试优先策略：只要可能，就在图中尽量深入，深度优先搜索总是对最近才发现的结点v的出发边进行探索，直到该结点的所有出发边都被发现为止。一旦结点v的所有出发边都被发现，搜索则回溯到v的前驱结点，来搜索该前驱结点的出发边。该过程一直持续到从源结点可以达到的所有结点都被发现为止。如果还存在尚未发现的结点，则深度优先搜索将从这些未被发现的结点中任选一个作为新的源结点，重复此过程。 #include us
算法导论-----最大优先队列
转角万里路的专栏
05-26 667
#define INIT_NUMBER 2 int reserve_number = 100; int heap_size; int length; typedef struct pair { int key; int value; }PAIR,*PAIRPOINT; //往最大优先队列中添加根结点 void MAX_HEAPIFY_ROOT(PAIR* A,int i) { int
算法导论：数据结构篇--红黑树详解
总结来说，《算法导论》中的红黑树章节是理解数据结构中的高级主题，特别是动态数据结构实现的重要部分，它为高效的搜索和排序算法提供了基础，是所有希望深入学习计算机科学和算法设计的学生和专业人士的必备参考...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值