C语言单链表实现红黑树

最新推荐文章于 2024-06-25 15:12:16 发布
原创 最新推荐文章于 2024-06-25 15:12:16 发布 · 337 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

红黑树是一种自平衡二叉查找树。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的：它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。红黑树的查找性能和AVL相对稍弱一点，但是实践表明，红黑树的插入过程中所需要进行的节点旋转次数比AVL树的要小。它的统计性能要好于平衡二叉树（AVL-树），因此红黑树在很多地方都有运用。

红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求:（为什么要增加这些限制? 利用对树中的结点 “红黑着色”的要求，降低了平衡性的条件，达到局部平衡）。

性质1：节点是红色或黑色
性质2：根节点是黑色的
性质3：每个叶子节点是黑色的
性质4：每个红色节点的两个子节点都是黑色的。（不能有两个连续的红色节点）
性质5：从任何一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

单链表结构：

typedef struct tagRoad
{
	unsigned short usSize;
	unsigned int uiLinkId;
	unsigned short usNameSize;
	unsigned int uiFlag;
	unsigned int uiClass;
	unsigned uiBranch;
	char acName[50];
}RoadMsg_t, * pRoadMsg_t;

typedef RoadMsg_t data_t;

typedef struct tagnode
{
	data_t data;
	int count;
	struct tagnode* next;
}linkNode_t, * pLinkNode_t;

PRBTREE CreateRBtree(void)
{
	PRBTREE ptree = (PRBTREE)malloc(sizeof(RBTREE));
	if (NULL == ptree)
	{
		printf("malloc is failure\n");
		return NULL;
	}
	ptree->nil = (PRBNODE)malloc(sizeof(RBNODE));
	if (NULL == ptree->nil)
	{
		printf("malloc is failure\n");
		return NULL;
	}

	ptree->nil->color = BLACK;
	ptree->nil->left = NULL;
	ptree->nil->right = NULL;
	ptree->nil->parent = NULL;

	ptree->root = ptree->nil;

	return ptree;
}

PRBNODE Insert_RBtree(PRBTREE ptree, data_t a)
{
	PRBNODE z = (PRBNODE)malloc(sizeof(RBNODE));
	if (NULL == z)
	{
		printf("malloc is failure\n");
		return;
	}
	z->key = a;
	z->parent = ptree->nil;
	z->left = ptree->nil;
	z->right = ptree->nil;
	z->color = RED;

	PRBNODE x = ptree->root;	//从根开始查找插入的位置
	PRBNODE y = ptree->nil;	    //用y记录：当前扫描节点的双亲节点。y指向x的parent

	while (x != ptree->nil)
	{
		y = x;			//y始终指向x的双亲
		if (z->key.uiLinkId < x->key.uiLinkId)
		{
			x = x->left;      //z插入x的左边
		}
		else
		{
			x = x->right;     //z插入x的右边
		}
	}	//z作为y的孩子插入
	z->parent = y;		//Z的双亲是y

	if (y == ptree->nil)	//z插入的是一棵空树
	{
		ptree->root = z;    //z是根
	}
	else
	{
		if (z->key.uiLinkId < y->key.uiLinkId)
		{
			y->left = z;	//z作为y的左孩子插入
		}
		else
		{
			y->right = z;	//Z作为y的右孩子插入
		}
	}
	//	z->left = ptree->nil;	//Z的左右孩子都为空
	//	z->right = ptree->nil;	//z插入在叶子节点的位置
	RBInsertFixup(ptree, z);
	return z;
}

/*
 *调整的整体思想：
 *通过旋转和改变颜色，自下而上调整。（z进行上溯）
 *使树满足红黑树的要求，成为一棵有效的红黑树
 *case1~case3：z的双亲p[z]是它的祖父p[p[z]]的左孩子
 *case4~case6：z的双亲p[z]是它的祖父p[p[z]]的右孩子
 */
void RBInsertFixup(PRBTREE ptree, PRBNODE z)
{
	PRBNODE y = ptree->nil;
	//若z为根，则p[z]是nil，颜色为black，不进入循环
	//若p[z]为黑色，与红z不冲突，亦无须进行调整
	while (z->parent->color == RED)
	{
		if (z->parent == z->parent->parent->left)//z的双亲是其祖父的左孩子
		{
			y = z->parent->parent->right;	//y是z的叔叔
			if (y->color == RED)	//case1 z有红叔
			{
				z->parent->color = BLACK;
				y->color = BLACK;
				z->parent->parent->color = RED;

				z = z->parent->parent;		//z的祖父变红，往上传播
			}
			else    //CASE2 CASE3 ,y为黑色
			{
				if (z == z->parent->right)  //CASE2  z是双亲的右子=>CASE3
				{
					z = z->parent;		//上溯至双亲
					leftRotate(ptree, z); //双亲左旋
				}
				//以下是case3,z是双亲的左孩子
				z->parent->color = BLACK;
				z->parent->parent->color = RED;

				rightRotate(ptree, z->parent->parent);
			}
		}
		else  //z的双亲是其祖父的右孩子
		{
			y = z->parent->parent->left;	//y是z的叔叔
			if (y->color == RED)	//case1 z有红叔
			{
				z->parent->color = BLACK;
				y->color = BLACK;
				z->parent->parent->color = RED;

				z = z->parent->parent;		//z的祖父变红，往上传播
			}
			else    //CASE2 CASE3 ,y为黑色
			{
				if (z == z->parent->left)  //CASE2  z是双亲的右子=>CASE3
				{
					z = z->parent;		//上溯至双亲
					rightRotate(ptree, z); //双亲左旋
				}
				//以下是case3,z是双亲的左孩子
				z->parent->color = BLACK;
				z->parent->parent->color = RED;

				leftRotate(ptree, z->parent->parent);
			}
		}
	}
	//有两处需要：1.z插入空树，2.case1，使得红传到了根。
	ptree->root->color = BLACK;

	return;
}

//假定right[x] != nil，节点有双亲。
int leftRotate(PRBTREE ptree, PRBNODE x)
{
	//step1
	PRBNODE y = x->right;

	//step2
	x->right = y->left;
	if (y->left != ptree->nil)
	{
		y->left->parent = x;
	}
	//step3：y取代x
	y->parent = x->parent;
	if (x->parent == ptree->nil)
	{
		ptree->root = y;
	}
	else
	{
		if (x == x->parent->left)
		{
			x->parent->left = y;
		}
		else
		{
			x->parent->right = y;
		}
	}
	//step4
	y->left = x;
	x->parent = y;

	return 0;
}

//假定left[y] != nil，节点有双亲。
int rightRotate(PRBTREE ptree, PRBNODE y)
{
	PRBNODE x = y->left;

	if (y->left == ptree->nil)
	{
		return -1;
	}
	//step1
	y->left = x->right;	//1.

	//step2 B取代y
	if (x->right != ptree->nil)
	{
		x->right->parent = y;
	}
	//step3:x取代y
	x->parent = y->parent;
	if (y->parent == ptree->nil)
	{
		ptree->root = x;
	}
	else
	{
		if (y == y->parent->left)
		{
			y->parent->left = x;
		}
		else
		{
			y->parent->right = x;
		}
	}
	//step4:x取代B
	x->right = y;
	y->parent = x;

	return 0;
}

int  Delete_RBtree(PRBTREE ptree, PRBNODE z, data_t* dval)
{
	PRBNODE x = ptree->nil;  //
	PRBNODE y = ptree->nil;  //

	if (z == ptree->nil)
	{
		return -1;
	}
	//CASE1，CASE2
	if ((z->left == ptree->nil) || (z->right == ptree->nil))
	{
		y = z;     	//后面实际删除的是y（物理删除）
	}
	else           //z的两孩子非空
	{
		y = TreeSuccessor(ptree, z); //y是z的中序后继
	}
	//此时y统一的是x的双亲节点，也是要删除的节点
	//x是要连接到p[y]的节点，以下要确定x
	//x保存y的唯一的非空孩子
	if (y->left != ptree->nil)
	{
		x = y->left;
	}
	else
	{
		x = y->right;
	}
	//以下是用x取代y与y的双亲短路if p[y]存在

	x->parent = y->parent;

	if (y->parent == ptree->nil)	//y是根
	{
		ptree->root = x;   //根指针指向x
	}
	else
	{
		if (y == y->parent->left)    //y是双亲的左孩子
		{
			y->parent->left = x;
		}
		else
		{
			y->parent->right = x;
		}
	}
	//store z's key
	*dval = z->key;
	//copy y的关键字和数据域到z
	if (y != z)  //CASE3
	{
		z->key = y->key;
	}
	if (y->color == BLACK)   //y的颜色为红色无须调整，1.不改变黑高 2.不会有相邻红色。3.不会是根
	{
		RBDeleteFixup(ptree, x);
	}
	free(y); //实际删除的是y节点
	return 0;
}
PRBNODE TreeSuccessor(PRBTREE ptree, PRBNODE x)
{
	return RBminmum(ptree, x->right);
}

void RBDeleteFixup(PRBTREE ptree, PRBNODE x)
{
	PRBNODE w = ptree->nil;	//用来保存x的兄弟
	while (x != ptree->root && (x->color == BLACK))	//x非根，双黑，被删节点y的黑色涂到x上了
	{
		if (x == x->parent->left)	//x是双亲的左孩子，case1 ~ CASE4
		{
			w = x->parent->right;	//w是x的兄弟
			if (w->color == RED)
			{
				w->color = BLACK;	//case1目标：将case1转为case2,3,4处理
				x->parent->color = RED;  //x的兄弟及双亲变色
				leftRotate(ptree, x->parent);
				w = x->parent->right;
			}//变为case2，case3，case4 新的兄弟w为黑色

			if ((w->left->color == BLACK) && (w->right->color == BLACK))
			{						//CASE2 x的兄弟w两子为黑
				w->color = RED;		//x及w上的黑色图到p[X]上。
				x = x->parent;	//P[X]为新的x，若p[x]原为黑，则双黑继续循环，否则终止
			}
			else      //case3,case4
			{
				if (w->right->color == BLACK)	//CASE3 W右孩子为黑，左孩子必为红
				{
					w->left->color = BLACK;
					w->color = RED;			//w及左孩子变色
					rightRotate(ptree, w);
					w = x->parent->right; //W指向新的兄弟
				}	//CASE3处理后变为case4，w右孩子为红，左孩子可红可黑

				w->color = x->parent->color;	//P[X]的颜色涂到w上
				x->parent->color = BLACK;
				w->right->color = BLACK;
				leftRotate(ptree, x->parent);

				x = ptree->root;	//退出循环
			}	//END CASE3，CASE4
		}
		else    //x是其双亲的右孩子，case5~case8与上面对称
		{
			w = x->parent->left;	//w是x的兄弟
			if (w->color == RED)
			{
				w->color = BLACK;	//case1
				x->parent->color = RED;  //x的兄弟及双亲变色
				rightRotate(ptree, x->parent);
				w = x->parent->left;
			}//变为case2，case3，case4 新的兄弟w为黑色

			if ((w->right->color == BLACK) && (w->left->color == BLACK))
			{						//CASE2 x的兄弟w两子为黑
				w->color = RED;		//x及w上的黑色图到p[X]上。
				x = x->parent;	//P[X]为新的x，若p[x]原为黑，则双黑继续循环，否则终止
			}
			else      //case3,case4
			{
				if (w->left->color == BLACK)	//CASE3 W右孩子为黑，左孩子必为红
				{
					w->right->color = BLACK;
					w->color = RED;			//w及左孩子变色
					leftRotate(ptree, w);
					w = x->parent->left; //W指向新的兄弟
				}	//CASE3处理后变为case4，w右孩子为红，左孩子可红可黑

				w->color = x->parent->color;	//P[X]的颜色涂到w上
				x->parent->color = BLACK;
				w->left->color = BLACK;
				rightRotate(ptree, x->parent);

				x = ptree->root;	//退出循环
			}	//END CASE3，CASE4
		}
	}
	x->color = BLACK;
	return;
}


//返回以t为根的子树的最大值，如果t是nil则返回nil
PRBNODE RBmaximum(PRBTREE ptree, PRBNODE t)
{
	/*	if (t == ptree->nil)
		{
			return NULL;
		}*/
	while (t->right != ptree->nil)
	{
		t = t->right;		//右子树的值是最大的，所以一直往右查询
	}
	return t;
}

//返回以t为根的子树的最小值，如果t为nil怎返回nil
PRBNODE RBminmum(PRBTREE ptree, PRBNODE t)
{
	while (t->left != ptree->nil)
	{
		t = t->left;
	}
	return t;
}
/*
 *查找节点t的后继节点，返回指向该节点的指针，如果没有后继则返回nil
 *在查找过程中，如果t的右子树不为空，那么返回右子树的最小节点即可
 *如果t的右子树为空，t的后继节点为某一祖先的父节点，
 *而且该祖先节点是作为其父亲节点的左孩子。
 * */
 //查找节点t的后继节点，返回指向该节点的指针，如果没有后继则返回nil
PRBNODE RBnext(PRBTREE ptree, PRBNODE t)
{
	PRBNODE p = ptree->nil;

	if (t->right == ptree->nil)	//右孩子为空时
	{
		p = t->parent;		//until p->left == t;
		while (p != ptree->nil && p->right == t)//后继节点为p->left == t时的p
		{
			t = p;
			p = t->parent;
		}
	}
	else
	{
		p = t->right;
		while (p->left != ptree->nil)
		{
			p = p->left;
		}
	}
	return p;
}

/*
 *查找节点t的前驱节点，返回指向该节点的指针，如果没前驱则返回nil
 *在查找过程中，如果t的左子树不为空，那么返回左子树的最大节点即可
 *如果t的右子树为空，t的前驱节点为某一祖先的父节点，
 *而且该祖先节点是作为其父亲节点的右孩子。
 * */
 //查找节点t的前驱节点
 //
PRBNODE RBprior(PRBTREE ptree, PRBNODE t)
{
	PRBNODE p = ptree->nil;
	if (t->left != ptree->nil)
	{
		p = t->parent;
		while (p != ptree->nil && p->left == t)
		{
			t = p;
			p = t->parent;
		}
	}
	else
	{
		p = t->left;
		while (p->right != ptree->nil)
		{
			p = p->right;
		}
	}
	return p;
}

// 中序遍历,以t为根的子树遍历
int midTraverse(PRBTREE ptree, PRBNODE t,FILE* fw)
{
	if (t == ptree->nil)
	{
		return 0;
	}
	//	putchar('(');
	midTraverse(ptree, t->left,fw);
	//	putchar(')');

	//printf("%d", t->key.uiLinkId);
	fprintf(fw, "tsize:%d\t linkid:%d\t nameSize:%d\t class:%d\t branch:%d\t flag:%d\t name:%s\t ",
		t->key.usSize, t->key.uiLinkId, t->key.usNameSize, t->key.uiClass, t->key.uiBranch, t->key.uiFlag, t->key.acName);  // UTF-8
	if (t->color == BLACK)
	{
		fprintf(fw,"color:B\n");
	}
	else
	{
		fprintf(fw, "color:R\n");
	}
	//	putchar('(');
	midTraverse(ptree, t->right,fw);
	//	putchar(')');
}

PRBNODE RBLocate(PRBTREE ptree, int a)
{
	PRBNODE p = ptree->root;
	while (p != ptree->nil)
	{
		if (a > p->key.uiLinkId)
		{
			p = p->right;
		}
		else if (a < p->key.uiLinkId)
		{
			p = p->left;
		}
		else
		{
			break;
		}
	}
	return p;
}
惑众
关注
Day_15 链表体系结构和红黑树
lbw18的博客
02-09 839
LinkedHashSet LinkedHashSet<E> : 元素不重复,元素无索引,元素存取有序 LinkedHashSet<E> 是 HashSet<E> 的子类; 数据结构之树结构 树结构常识 红黑树结构 红黑树添加元素的规律(了解) TreeSet TreeSet<E> : 元素不重复,元素可以排序(元素存取无序),元素无索引 常用的对象类型默认排序规则: 整数存储在TreeSet集合中默认升序!! 字符串存在TreeSet集
《算法导论》笔记（5）链表到红黑树
nklofy的专栏
02-05 915
基本数据结构：链表，队列，散列表，二叉树，红黑树。 栈和队列都是抽象的结构，不一定是物理连续的内存空间。但必须实现push()和pop()的抽象接口。链表有单、双向链表和循环链表。可按照iterator++或者iterator--的方式访问。另外要注意的是插入或删除时对指针的操作。某些语言不支持指针和对象，那么实现链表有2种方式。多维数组或1维数组。多维数组的实现方式是A[i][j][k]中的j
链表-单向链表-红黑树
qq_28770419的博客
03-13 345
接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。看完API，我们总结一下：它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
红黑树的插入删除-红黑树动态顺序统计
shakingWaves的专栏
02-25 988
#include #include #include using namespace std; typedef struct rb_node{//带父节点的二叉树 int value; rb_node *left,*right,*parent; bool rb;//rb=0表示结点,rb=1表示红结点 int size;//存储左右子树大小和该结点之和 }rb_node,*pRBNo
红黑树的链表实现，以及使用
10-14
红黑树的链接实现，完成增加，删除结点，寻找前缀后缀节点等。
严蔚敏数据结构c语言版本可运行源码、完全c语言代码实现.zip
06-14
4. **树**：二叉树、平衡树（如AVL树和红黑树）等，源码将涵盖插入、删除、查找等基本操作，以及树的遍历算法。 5. **图**：邻接矩阵和邻接表的实现，以及图的遍历算法（深度优先搜索DFS和广度优先搜索BFS）。 6. ...
用C语言来实现数据结构和算法.zip
10-09
5. **树**：二叉树是最简单的树形结构，包括二叉查找树、平衡树（如AVL树和红黑树）、堆等。C语言实现树通常涉及指针的复杂操作。 6. **图**：图由顶点和边组成，用于表示对象之间的关系。C语言可以通过邻接矩阵或...
数据结构C语言代码实现
10-29
2. **树形结构**：二叉树、平衡树（AVL树、红黑树）、B树、B+树。二叉树是最简单的一种树，有左子节点和右子节点；平衡树则确保了查找、插入和删除操作的时间复杂度为O(logn)；B树和B+树常用于数据库索引，能有效...
高性能C数据结构，双向列表、红黑树、哈希表等！.zip
06-17
本资源包主要聚焦于三种经典且高效的数据结构：双向列表、红黑树和哈希表，这些都是C语言实现的。接下来，我们将深入探讨这些数据结构及其在实际应用中的重要性。 首先，双向列表是一种线性数据结构，它允许我们在...
C语言和cpp实现的数据结构
01-02
1. **STL容器**：如`std::vector`代表动态数组，`std::list`代表双向链表，`std::set`和`std::map`则基于红黑树实现，提供高效查找。 2. **智能指针**：如`std::unique_ptr`和`std::shared_ptr`，用于自动管理内存，...
链表和红黑树测试代码
10-09
linux内核双向环形链表和红黑树，源码学习，摘录部分代码编译成库，进行测试
说下什么是链表 什么是红黑树
weixin_42600407的博客
01-07 441
链表是一种常见的数据结构，它由一个个节点组成，每个节点都有一个数据域和一个指向下一个节点的指针域。链表中的节点并不是连续存储在内存中的，而是存储在稀疏分布的各个位置。 红黑树是一种自平衡二叉查找树，它在保证二叉查找树的性质的同时，还能保证查询、插入、删除的时间复杂度较小。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。它通过对这个颜色属性进行限制，使得查询、插入、删除的时间复杂度能够保持在较小...
【HashMap】链表和红黑树互相转换的几种情况和数组的扩容机制
hui_zai_的博客
06-06 5619
链表和红黑树互相转换的几种情况和数组的扩容机制
数据结构——红黑树
m0_70325779的博客
06-26 705
这是我们再进行判断，此时判断要站在旋转支点15的基础上进行判断，15的父节点16为红色，叔叔节点为Nil黑色，此时各位就会发现，已经和上述插入节点14时的情况相同了，仍然是进行三步操作。第一：红黑树它本身也是一个自平衡的二叉搜索树，但不是高度平衡的，和平衡二叉树略有区别，是一种特殊的二叉搜索树，在原本的二叉树节点的基础上，多了一个存储改节点颜色的数据。第四步：插入节点22，22与20作比较，比20大，插入到20的右边，再与23作比较，插入到23的左边，默认为红色，插入后为如下。各位觉得到这里就完了吗？
HashMap底层数据结构（数组+链表+红黑树）
热门推荐
程序员劝退师的博客
04-28 1万+
回顾一下HashMap的底层数据结构 HashMap底层实现JDK<=1.7数组+链表，JDK>=1.8数组+链表+红黑树；HashMap这一个类型底层涉及到3中数据类型，数组、链表、红黑树，其中查询速度最快的是数组，时间复杂度是O(1),链表数据量少的时候还行，数据量过大性能就一般了，它的时间复杂度是O(N)，红黑树在数据量打的时候性能会比链表要好，他的时间复杂度是O(logn),这...
HashMap之 链表转红黑树
zhang2383906154的博客
11-15 5978
当链表长度大于等于TREEIFY_THRESHOLD（默认8）时，同时链表长度大于等于 MIN_TREEIFY_CAPACITY(默认64)就会触发链表转红黑树的情况，当然，在删除(remove)数据或其它原因调整了大小，当红黑树节点小于或等于6以后，会回复成链表形态。 1、为什么链表要转红黑树 每次遍历链表，平均查询的时间复杂度是O(n),n是链表长度。红黑树和链表的查询性能不一样 由于红黑树自平衡的特点，可以防止不平衡的情况发生，所以红黑树把查询的时间复杂度始...
JAVA8 hashmap源码阅读笔记(红黑树链表)
just xiaoqiang
07-18 1万+
一：hashmap的13 个成员变量 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; -> 数组默认初始容量：16 static final int MAXIMUM_CAPACITY = 1 << 30; -> 数组最大容量2 ^ 30 次方 static final float DEFAULT_LOAD_FACTOR = 0.75f;
常见的数据结构——栈、队列、数组、链表和红黑树
qq_39368007的博客
01-29 429
链表 链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。 每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 我们常说的链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。 简单的说，采用该结构的集合，对元素的存取有如下的特点： 红黑树 ...
数组，链表，红黑树介绍以及性能对比实验
最新发布
qq_51118755的博客
06-25 688
以前学了数组，链表，红黑树的相关知识，今天用Java对它们三者在插入，删除，查找等方面做一个性能对比测试，今天分享给大家😊。
C语言实现基础数据结构源代码详解
二叉树在数据结构中有广泛的应用，例如二叉搜索树、平衡二叉树（AVL树）、红黑树等。二叉树的遍历方法有前序遍历、中序遍历、后序遍历和层次遍历等。在C语言中，二叉树的节点可以用结构体表示，通常包含数据域和两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值