红黑树的C实现

最新推荐文章于 2021-01-12 15:43:05 发布
最新推荐文章于 2021-01-12 15:43:05 发布
阅读量760 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzhengyuan123/article/details/22827413
版权

看了nginx的源码，其中的定时器采用的数据结构是红黑树，而linux内核中高级数据结构也采用了红黑树，由此可见红黑树效率确实很高。

红黑树是一种局部平衡树，不像AV树那样绝对平衡。但是实现起来也比较复杂，鄙人水平有限，在了解了红黑树原理之后自己用C实现了

红黑树，花了一天时间调试才通过，建议大家也写写，有得地方注释不够清楚，下次补充。


一般的，红黑树，满足以下性质，即只有满足以下全部性质的树，我们才称之为红黑树：
 1）每个结点要么是红的，要么是黑的。
 2）根结点是黑的。
 3）每个叶结点，即空结点（NIL）是黑的。
 4）如果一个结点是红的，那么它的俩个儿子都是黑的。
 5）对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点 

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define RED 1
#define BLOCK 0

//瀹氫箟鑺傜偣
typedef struct myrbtree
{
	int key;   //鑺傜偣鍏抽敭瀛楋紝鐢ㄤ互鍞竴鏍囪瘑涓€涓妭鐐�
	struct myrbtree *parent,*left,*right;
	int color;  //绾㈤粦灞炴€�
}Rbnode,*Rbpoint;

Rbpoint sentinel ;  //鍝ㄥ叺锛屾墍鏈夌殑鍙跺瓙鑺傜偣鎸囧悜鍝ㄥ叺

Rbpoint createnode(int key)  //鍒涘缓涓€涓┖鑺傜偣
{
	Rbpoint new = (Rbpoint)malloc(sizeof(Rbnode));
	new->key = key;
	new->parent = sentinel;
	new->left = sentinel;
	new->right = sentinel;
	new->color = RED;
	return new;	
}

//涓牴閬嶅巻浜屽樊鏍戝嚱鏁�
static void firstroot(Rbpoint root)
{
	Rbpoint tmp = root;
	if(tmp->left != sentinel)
	{
		firstroot(tmp->left);
	}
	printf("%d,",tmp->key);
	if(tmp->right != sentinel)
	{
		firstroot(tmp->right);
	
	}
}

//鍒涘缓鏍硅妭鐐瑰嚱鏁�

Rbpoint createroot(int key)
{
	Rbpoint root = createnode(key);
	root->color = BLOCK; //鏍硅妭鐐瑰畾涔変负榛戣壊
}

Rbpoint rbbalance(Rbpoint ,Rbpoint );  
Rbpoint leftrobate(Rbpoint ,Rbpoint);
Rbpoint rightrobate(Rbpoint ,Rbpoint);


Rbpoint rbinsert(Rbpoint root,Rbpoint new)  //鎻掑叆涓€涓妭鐐癸紝root涓烘牴,new涓烘柊鎻掑叆鑺傜偣
{
	if(root->color != BLOCK)
	{
		printf("root not BLOCK\n");
		exit(0);
	}
	if(root == sentinel)
		return new;
	Rbpoint tmp = root;
	while(tmp != sentinel) //绾㈤粦鏍戞槸鎺掑簭鏍戯紝鏂拌妭鐐规彃鍏ュ埌鏍戜腑骞舵帓搴�
	{
		if(new->key > tmp->key)
		{
			if(tmp->right == sentinel) //澶т簬褰撳墠鑺傜偣锛屽垯寰€鍙虫煡鎵剧┖浣嶆彃鍏�
			{
				tmp->right = new;
				new->parent = tmp;
				break;
			}
			else
				tmp = tmp->right;
			
		}
		else     //灏忎簬褰撳墠鑺傜偣锛屽線宸︽煡鎵剧┖浣嶆彃鍏�
		{
			if(tmp->left == sentinel)
			{
				tmp->left = new;
				new->parent = tmp;
				break;
			}
			else
				tmp = tmp->left;
		
		}
	}
	
	root = rbbalance(root,new);  //鎻掑叆涔嬪悗闇€瑕佸钩琛★紝閫氳繃绉诲姩锛岀炕杞互婊¤冻绾㈤粦鏍戞潯浠�
	return root;
}


Rbpoint leftrobate(Rbpoint root,Rbpoint new)  //宸︾炕杞�
{
	Rbpoint tmp;
	if(new == root)
		return root;
	tmp = new->parent;
	if(tmp->parent != sentinel) //缈昏浆鐨勬牴涓烘牴鑺傜偣
	{
		if(tmp->parent->left == tmp)
			tmp->parent->left = new;
		else
			tmp->parent->right = new;
		new->parent = tmp->parent;
		tmp->right = new->left;
		new->left->parent = tmp;
		tmp->parent = new;
		new->color = BLOCK;
		tmp->color = RED;
		new->left = tmp;
		return root;
	}
	else          //缈昏浆鐨勬牴涓嶄负鏍硅妭鐐�
	{
		new->parent = sentinel;
		tmp->right = new->left;
		new->left->parent = tmp;
		tmp->parent = new;
		new->color = BLOCK;
		tmp->color = RED;
		new->left = tmp;
		return new;
	}
}

Rbpoint rightrobate(Rbpoint root,Rbpoint new)  //鍙堢炕杞紝缈昏浆杩囩▼涓庡乏缈昏浆绫讳技
{
	Rbpoint tmp;
	tmp = new->parent;
	if(tmp->parent != sentinel)
	{
		if(tmp->parent->right == tmp)
		tmp->parent->right = new;
		else
		tmp->parent->left = new;

		new->parent = tmp->parent;
		tmp->left = new->right;
		new->right->parent = tmp;
		tmp->parent = new;
		new->color = BLOCK;
		tmp->color = RED;
		new->right = tmp;
		return root;
	}
	else
	{
		new->parent = sentinel;
		tmp->left = new->right;
		new->right->parent = tmp;
		new->color = BLOCK;
		tmp->color = RED;
		new->right = tmp;
		tmp->parent = new;
		return new;
	}
}

Rbpoint rbbalance(Rbpoint root,Rbpoint new)  //瀵逛簩鎿︽爲杩涜骞宠　鍖�
{
	Rbpoint tmp;
	if(new == root)
		return root;
	if(new->parent->color == BLOCK)
		return root;
	if((new->parent->parent->left != sentinel)&&(new->parent->parent->right != sentinel)&&(new->parent->parent->left->color == RED)&&(new->parent->parent->right->color == RED))
	{
		new->parent->parent->left->color = BLOCK;
		new->parent->parent->right->color = BLOCK;
		if(new->parent->parent == root)
		{
			root->color = BLOCK;
			return  root;
		}
		new->parent->parent->color = RED;
		tmp = new->parent->parent;
		rbbalance(root,tmp);
	}
	else if((new->parent->left == new)&&(new->parent->parent->left == new->parent))
	{
		return rightrobate(root,new->parent);
	}
	else if((new->parent->right == new)&&(new->parent->parent->right== new->parent))
	{
		return leftrobate(root,new->parent);
	}
	else if((new->parent->right == new)&&(new->parent->parent->left == new->parent))
	{
		root = leftrobate(root,new);
		return rightrobate(root,new);
	}
	else if((new->parent->left==new)&&(new->parent->parent->right == new->parent))
	{
		root = rightrobate(root,new);
		return leftrobate(root,new);
	}
	
}

Rbpoint rbfind(Rbpoint root,int key)  //閫氳繃閿煡鎵炬爲涓殑鑺傜偣
{
	Rbpoint tmp = root;
	while(tmp->key != key)
	{
		if(tmp->key > key)
		{
			tmp = tmp->left;
			continue;
		}
		else
		{
			tmp = tmp->right;
			continue;
		}
	}
	return tmp;
}

Rbpoint findmin(Rbpoint root,Rbpoint right)   //鏌ユ壘鏍戜腑鐨勬渶灏忚妭鐐�
{
	if(right == sentinel)
		return root;
	Rbpoint tmp = right;
	while(tmp->left != sentinel)
		tmp = tmp->left;
	return tmp;
}

Rbpoint freenode(Rbpoint root,Rbpoint node)   //閲婃斁涓€涓妭鐐�
{
	if(node->parent == root)
		node->parent->right = node->right;
	else if(node->key > node->parent->key)
		node->parent->right = node->right;
	else
		node->parent->left = node->right;
	if(node->right != sentinel)
		node->right->parent = node->parent;
	free(node);
}

Rbpoint rbdelete(Rbpoint root,int key)   //鍒犻櫎涓€涓妭鐐�
{
	Rbpoint delz = rbfind(root,key);
	if((delz == root)&&(delz->left == delz->right))
	{
		free(root);
		return sentinel;
	}
	Rbpoint tmpy = findmin(delz,delz->right);
	Rbpoint tmpx;
	if(tmpy != delz)
		tmpx = tmpy->right;
	else
  	{
		tmpy->right = tmpy->left;
		tmpy->left = sentinel;
		tmpx = tmpy->right;
	}
	delz->key = tmpy->key;
        tmpy->key = key;
	Rbpoint tmp = tmpy->parent;
		
	if(tmpy->color == RED)
	{
		freenode(delz,tmpy);
		return root;
	}
			
	freenode(delz,tmpy);
	if((tmpx!=sentinel)&&(tmpx->color == RED))
	{
		tmpx->color = BLOCK;
		return root;
	}
	int flag = 1,color;
	Rbpoint tmpw ;
	Rbpoint tmpp ;
	while(flag)
	{

	       if(((tmpx == sentinel)&&(tmpx == tmp->left))||((tmpx != sentinel)&&(tmpx->key < tmpx->parent->key)))
		{
			if(tmpx == sentinel)
               	 	{
                        	tmpw = tmp->right;
                        	tmpp = tmp;
                	}
			else
			{
				tmpw = tmpx->parent->right;
       		 		tmpp = tmpx->parent;
			}
			if(tmpw->color == RED)
			{
				tmpw->color = BLOCK;
				tmpp->color = RED;
				root = leftrobate(root,tmpw);
				continue;
			}
			if((tmpw->color == BLOCK)&&(tmpw->right!=sentinel)&&(tmpw->right->color == RED))
			{
				color = tmpw->color;
				tmpw->color = tmpp->color;
				tmpp->color = color;
				tmpw->right->color = BLOCK;
				root = leftrobate(root,tmpw);
				return root;
			}
			if((tmpw->color == BLOCK)&&(tmpw->left!=sentinel)&&(tmpw->left->color==RED)&&(tmpw->right!=sentinel)&&(tmpw->right->color==BLOCK))
			{
				color = tmpw->color;
				tmpw->color = tmpw->left->color;
				tmpw->left->color = color;
				root  = rightrobate(root,tmpw->left);
				continue;
			}
			if(tmpw->color == BLOCK)
			{
				tmpw->color = RED;
				if(tmpp->color == RED)
				{
					tmpp->color = BLOCK;
					return root;
				}
				if(tmpp->parent == sentinel)
					return root;
				tmpx = tmpw->parent;
				continue;
			}
		}
		else
		{
			if(tmpx != sentinel)
			{
				tmpw = tmpx->parent->left;
       		 		tmpp = tmpx->parent;
			}
			else
			{
				tmpw = tmp->left;
				tmpp = tmp;
			}
			if(tmpw->color == RED)
			{
				tmpw->color = BLOCK;
				tmpp->color = RED;
				root = rightrobate(root,tmpw);
				continue;
			}
			if((tmpw->color == BLOCK)&&(tmpw->left!=sentinel)&&(tmpw->left->color == RED))
			{
				color = tmpw->color;
				tmpw->color = tmpp->color;
				tmpp->color = color;
				tmpw->left->color = BLOCK;
				root = rightrobate(root,tmpw);
				return root;
			}
			if((tmpw->color == BLOCK)&&(tmpw->left!=sentinel)&&(tmpw->left->color==BLOCK)&&(tmpw->right!=sentinel)&&(tmpw->right->color==RED))
			{
				color = tmpw->color;
				tmpw->color = tmpw->right->color;
				tmpw->right->color = color;
				root = leftrobate(root,tmpw->right);
				continue;
			}
			if(tmpw->color == BLOCK)
			{
				tmpw->color = RED;
				if(tmpp->color == RED)
				{
					tmpp->color = BLOCK;
					return root;
				}
				if(tmpp->parent == sentinel)
					return root;
				tmpx = tmpw->parent;
				continue;
			}
		}
	}
}

void  testpc(Rbpoint root,Rbpoint test)
{
	if(test == root)
		return ;
	if(test->key > test->parent->key)
	{
		if(test->parent->right != test)
		{
			printf("insert err %d\n",test->key);
			exit(0);
		}
	}
	else
	{
		if(test->parent->left != test)
		{
			printf("insert err %d\n",test->key);
			exit(0);
		}
	}
}

void midroot(Rbpoint root)   //鍏堟牴閬嶅巻
{
	if(root!=sentinel)
		printf("%d(%d),",root->key,root->color);
	if(root->left!=sentinel)
		midroot(root->left);
	if(root->right!=sentinel)
		midroot(root->right);
	//printf("\n");
}

int main(int argc,char **argv)
{
	
        sentinel = (Rbpoint)malloc(sizeof(Rbnode));
	printf("test createnode...\n");
	Rbpoint root = createroot(1);
	printf("test.key:%d,test.color:%d\n***************\n",root->key,root->color);
	printf("test insert....\n");
	Rbpoint test = createnode(2);
	root = rbinsert(root,test);
	int keytest[10000];
	int i;
	for(i=5;i<1000;i++)
	{
		test = createnode(i);
		root = rbinsert(root,test);
		testpc(root,test);
	}
	
	firstroot(root);
	midroot(root);
	printf("test firstroot done:.....\n");
	for(i=10;i<450;i++)
	{
		root = rbdelete(root,i);
		firstroot(root);
		printf("\n");
		midroot(root);
		printf("\n");
	}
	printf("test firstroot:.....\n");
}


liuzhengyuan123
关注
专栏目录
C语言实现红黑树(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-22 800
C语言实现红黑树节点定义实现以下10个接口完整实现和main测试源码 节点定义 typedef struct node { int val; struct node *par; struct node *left; struct node *right; int color; } Node; 实现以下10个接口 Node *newNode(int val, Node *par); int isLeaf(Node *n); Node *leftRotate(Node
红黑树----红黑树的C实现完整源码
JK198310的专栏
08-12 1316
红黑树C源码实现与剖析 作者：July 、那谁   时间：二零一一年一月三日 ------------------------- 前言：     红黑树作为一种经典而高级的数据结构，相信，已经被不少人实现过，但不是因为程序不够完善而无法运行，就是因为程序完全没有注释，初学者根本就看不懂。     此份红黑树的c源码最初从linux-lib-rbtree.c而来，后经一网友那谁（htt
红黑树的实现源码(第二次修订版)
人不一定要生得漂亮，但一定要活得漂亮！
11-22 491
我曾经写过两个两个红黑树的实现, 分别在:http://www.cppblog.com/converse/archive/2006/10/07/13413.htmlhttp://www.cppblog.com/converse/archive/2007/11/28/37430.html最近因为要给ccache加入红黑树的支持, 找出来曾经实现的代码作为参考, 这才发现原来的实现都是有问题的,也怪我
红黑树的实现和代码
shiwenliang的专栏
12-22 450
/*** Introduction to Algorithms, Second Edition * 13 Red-Black Trees* * 红黑树的条件：* 1.每个节点标记为“红”或“黑”。* 2.根标记为“黑”。* 3.所有叶节点(nil)标记为“黑”。* 4.如果一个节点为“红”，则它的两个节点都为“黑”。* 5.对每个的节点，从该节点至后继叶节点包含相同数量的“黑”节点。* @auth
红黑树（rb_tree） 源代码
脚踏实地，用心编写出客户满意的代码，为公司创造出应有的价值。
05-17 1077
红黑树 （rb_tree）源代码
红黑树的c实现源码与教程
01-03
红黑树的c实现源码与剖析 原作者：那谁 源码剖析作者：July ===================== July说明： 由于原来的程序没有任何一行注释，我把它深入剖析，并一行一行的添加了注释， 详情请参见此文： 教你彻底实现红黑树：...
红黑树的C实现，算法导论的红黑树C实现
03-21
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972...《算法导论》这本书提供了详细的红黑树理论和实现指导，是学习红黑树的重要资源。通过阅读书中的代码和实践，可以深入理解红黑树的工作原理及其C语言实现细节。
Linux内核中红黑树算法的实现详解
09-15
在Linux内核中，红黑树的实现位于`include/linux/rbtree.h`和`lib/rbtree.c`两个文件中。 首先，我们来了解一下红黑树的基本特性： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 如果一个节点是红色...
red-black-tree:C - 左倾红黑树实现
06-02
以下是C语言实现左倾红黑树可能涉及的关键结构和函数： 1. **结构定义**： - 节点结构：定义包含键值、颜色、左子节点、右子节点以及父节点的结构体。 - 红黑树结构：可能包含根节点和其他辅助方法。 2. **初始...
红黑树与区间树算法实现
04-08
在实验中，`RedBlackTree.c`和`RedBlackTree.h`文件包含了红黑树的实现，包括插入、删除、旋转、查找等操作。`Tree.dot`文件用于生成红黑树的图形表示，通过graphviz工具可视化。 区间树是一种特殊的树形数据结构，...
红黑树讲解(超短红黑树c代码150行)
teslali
03-04 739
红黑树 说明: 图片信息来源于计蒜客数据结构红黑树一讲 注意自己动手多画 介绍 红黑树是一种自平衡二查查找树，是由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。 红黑树与AVL相比，他牺牲了部分平衡性以在插入和删除操作时，减少...
STL源码剖析---红黑树原理详解上
后而来者
08-24 190
原文地址：http://blog.csdn.net/hackbuteer1/article/details/7740956 一、红黑树概述 红黑树和我们以前学过的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。不过自从红黑树出来后，AVL树就被放到了博物馆里，据说是红黑树有更好的效率，更高的统计性能。这一点在我们了解了红黑树的实现原理后，就会有更加深切的体会。 红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL树中的非常严
手把手教你实现红黑树——从图示到代码
pp5354chun的博客
01-12 327
前置知识：二叉搜索树 红黑树是进阶版的二叉搜索树，普通的二叉搜索树在顺序键构造时，复杂度为O(n)： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lE9RPTUR-1610367756425)(https://s3.ax1x.com/2021/01/10/slPv2n.png)] 而红黑树则通过为节点额外添加一些属性改善了这一问题，无论以何种顺序构造红黑树，都能得到O(log n)的复杂度 要想学习红黑树，首先需要了解2-3树 2-3树 对于二叉搜索树，每个节点有一个键和两
红黑树（附完整C代码）
热门推荐
weewqrer的博客
07-09 2万+
版权声明：原创不易，转载请注明转自weewqrer 红黑树红黑树简介首先红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或者BLACK。通过对一条从根节点到NIL叶节点（指空结点或者下面说的哨兵）的简单路径上各个结点在颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡的。 用途红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可
红黑树的c实现完整源码
dinongxu8804的博客
01-03 337
红黑树c源码实现与剖析 作者：July、那谁时间：二零一一年一月三日 ------------------------- 前言： 红黑树作为一种经典而高级的数据结构，相信，已经被不少人实现过，但不是因为程序不够完善而无法运行，就是因为程序完全没有注释，初学者根本就看不懂。 此份红黑树的c源码最初从linux-lib-rbtree.c而来，后经一网友那谁（...
二叉树
影子
09-08 649
#include struct tree //澹版槑鏍戠殑缁撴瀯 { struct tree *left; int data; struct tree *right; }; typedef struct tree treenode; type treenode *b_tree; //澹版槑浜屽弶鏍戦摼琛? //鎻掑叆浜屽弶鏍戠殑鑺傜偣 b_tree insert_nod
用c++实现红黑树的判断、插入、遍历操作
岩枭的博客
07-26 4881
红黑树        红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是Red或Black。通过对任何一条从根到叶子简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似于平衡。 红黑树是满足下面红黑性质的二叉搜索树： 1. 每个节点，不是红色就是黑色的； 2. 根节点是黑色的； 3. 如果一个节点是红色的，则它的两个子节点是黑色的；
红黑树的C实现完整代码
zhuzhenyang110的专栏
03-05 886
 红黑树C源码实现与剖析 作者：July 、那谁   时间：二零一一年一月三日 ------------------------- 前言：     红黑树作为一种经典而高级的数据结构，相信，已经被不少人实现过，但不是因为程序不够完善而无法运行，就是因为程序完全没有注释，初学者根本就看不懂。     此份红黑树的c源码最初从linux-lib-rbtree.c而来，后经一网友
算法导论学习---红黑树详解之插入(C语言实现)
荒野孤鹰
07-05 4459
前面我们学习二叉搜索树的时候发现在一些情况下其高度不是很均匀，甚至有时候会退化成一条长链,所以我们引用一些”平衡”的二叉搜索树。红黑树就是一种”平衡”的二叉搜索树，它通过在每个结点附加颜色位和路径上的一些约束条件可以保证在最坏的情况下基本动态集合操作的时间复杂度为O(nlgn).下面会总结红黑树的性质，然后分析红黑树的插入操作，并给出一份完整代码。先给出红黑树的结点定义：#define RED 1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值