红黑树的系列函数

于 2021-07-21 20:20:23 发布
阅读量128 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45396618/article/details/118975402
版权

快捷跳转

main.c

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

void show_menu(void){
	printf("*******(红黑树功能测试)**********\n");
	printf("**1. 插入元素 \n");
	printf("**2. 删除元素 \n");
//	printf("**3. 查找某元素是否在树中 \n");
	printf("**4. 树是否为空 \n");
	printf("**5. 树中元素个数 \n");
	printf("**6. 树的高度 \n");
	printf("**7. 树的先序遍历 \n");
	printf("**8. 树的中序遍历 \n");
	printf("**9. 树的后序遍历 \n");
//	printf("**10.树的层序遍历 \n");
	printf("**11. 清空树 \n");
	printf("**0. 退出 \n");
	printf(">>>>");
}

void travel(ETYPE val,char color){
	printf("%d(%s) ",val,color==RED?"RED":"BLACK");
}

void test_rb_tree(void){
	RBTree tree = NULL;
	rbtree_init(&tree);
	while(true){
		show_menu();
		int opt = 0;
		int elem = 0;
		int ret = 0;
		bool f = true;
		scanf("%d",&opt);
		switch(opt){
			case 1:
				printf("请输入要插入二叉排序树中的元素:");
				scanf("%d",&elem);
				ret = rbtree_insert(&tree,elem);
				if(ret == 0){
					printf("插入成功！\n");
				}else{
					if(ret == -1){
						printf("树中已有该元素，插入失败!\n");
					}else{
						printf("插入失败!内存问题!\n");
					}
				}
				break;
			case 2:
				printf("请输入要删除的元素:");
				scanf("%d",&elem);
				ret = rbtree_delete(&tree,elem);
				if(ret == 0){
					printf("删除成功!\n");
				}else{
					printf("删除失败!树中没有该元素!\n");
				}
				break;
			case 3:
//				printf("请输入要查找树中是否存在的元素:");
//				scanf("%d",&elem);
//				if(val_tree_contains(tree,elem)){
//					printf("树中存在该元素!\n");
//				}else{
//					printf("树中没有该元素!\n");
//				}
				break;
			case 4:
				rbtree_empty(tree)?puts("空空如也！\n"):puts("树中有元素!\n");
			case 5:
				printf("树中元素个数:%u\n",rbtree_size(tree));
			case 6:
				printf("树的高度为:%u\n",rbtree_hight(tree));
				break;
			case 7:
				rbtree_front_travel(tree,travel);
				printf("\n");
			case 8:
				rbtree_mid_travel(tree,travel);
				printf("\n");
			case 9:
				rbtree_back_travel(tree,travel);
				printf("\n");
			case 10:
				//rbtree_layer_travel(tree,travel);
				printf("\n");
				break;
			case 11:
				rbtree_clear(&tree);
				break;
			case 0:
				rbtree_destroy(&tree);
				return; 
		}
	}
}

int main(int argc, char *argv[]) {
	test_rb_tree();
	return 0;
}

rbtree.h

#ifndef _RBTREE_H__
#define _RBTREE_H__

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

typedef int ETYPE;
enum COL{RED=0,BLACK=1}; 
typedef struct RBNode{
	ETYPE elem;
	char color;             //颜色   RED  BLACK 
	struct RBNode *lchild;
	struct RBNode *rchild;
	struct RBNode *parent;  //记录父结点 
}RBNode;
typedef struct RBNode * RBTree;

int rbtree_insert(RBTree *proot,ETYPE elem);
int rbtree_delete(RBTree *proot,ETYPE elem);

void rbtree_init(RBTree *proot);
bool rbtree_empty(RBTree root);
size_t rbtree_size(RBTree root);
size_t rbtree_hight(RBTree root);

void rbtree_front_travel(RBTree root,void (*travel)(ETYPE,char));
void rbtree_mid_travel(RBTree root,void (*travel)(ETYPE,char));
void rbtree_back_travel(RBTree root,void (*travel)(ETYPE,char));
void rbtree_clear(RBTree *proot);
void rbtree_destroy(RBTree *proot);
#endif //_RBTREE_H__

rbtree.c

#include "rbtree.h"
/*
typedef int ETYPE;
enum COL{RED=0,BLACK=1}; 
typedef struct RBNode{
	ETYPE elem;
	char color;             //颜色   RED  BLACK 
	struct RBNode *lchild;
	struct RBNode *rchild;
	struct RBNode *parent;  //记录父结点 
}RBNode;
typedef struct RBNode * RBTree;
*/

#define ISBLACK(node) (node==NULL||node->color==BLACK)

static struct RBNode *rbtree_create_node(ETYPE elem,struct RBNode *parent){
	struct RBNode *node = (struct RBNode*)malloc(sizeof(struct RBNode));
	if(node!=NULL){
		node->elem = elem;
		node->color = RED;//插入的结点都是红色  保证了红黑树5的特性  可能会违反性质3
		node->lchild = NULL;
		node->rchild = NULL; 
		node->parent = parent;
	}
}

//对node结点进行左旋  
/*
          ||                                  ||
        node                                right 
        /  \                               //   \
      left  right    node左旋            node   rr
            /  \                         /  \\
           rl  rr                      left  rl
*/
static void left_rotate(RBTree *proot,struct RBNode *node){
	struct RBNode *right = node->rchild;
	right->parent = node->parent;
	if(node->parent!=NULL){
		if(node == node->parent->lchild){//node是父结点的左孩子 
			node->parent->lchild = right;
		}else{//node是父结点的右孩子 
			node->parent->rchild = right;
		}
	}else{//node的父结点不存在 说明 node本来是根结点   right作为根结点 
		*proot = right;
	}
	node->rchild = right->lchild;
	if(right->lchild!=NULL)
		right->lchild->parent = node;
	right->lchild = node;
	node->parent = right;
} 
//对node结点进行右旋
/*
          |                                  |
        node                                left 
        /  \                               /    \
      left  right    node右旋            ll     node
      /  \                                      /  \
     ll  lr                                    lr   right
*/
static void right_rotate(RBTree *proot,struct RBNode *node){
	struct RBNode *left = node->lchild;
	left->parent = node->parent;
	if(node->parent!=NULL){
		if(node == node->parent->lchild){
			node->parent->lchild = left;
		}else{
			node->parent->rchild = left;
		}
	}else{
		*proot = left;
	}
	node->lchild = left->rchild;
	if(left->rchild!=NULL)
		left->rchild->parent = node;
	node->parent = left;
	left->rchild = node;
} 

//*proot指向根结点   node为新插入的结点 
static void rbtree_insert_repair(RBTree *proot,struct RBNode *node){
	//node是当前结点得是红色  parent 
	struct RBNode *parent = node->parent;
	//两个连续红色的结点 
	while(node->color == RED && (parent!=NULL && parent->color == RED)){
		//node为红  parent为红  
		struct RBNode *gp = parent->parent;   //祖父结点
		struct RBNode *uncle = gp->lchild==parent?gp->rchild:gp->lchild;
		if(uncle!=NULL && uncle->color==RED){//叔叔为红 
			parent->color = BLACK;
			uncle->color = BLACK;
			gp->color = RED;
			node = gp;//把祖父置红之后 需要继续向上讨论 
			parent = node->parent; 
		}else{//叔叔为黑 
			if(parent==gp->lchild){//父为左  叔为右 
				if(node==parent->rchild){//自己为右 
					left_rotate(proot,parent);//左旋之后  父结点变成左孩子 
					node = parent;
					parent = node->parent; 
				} 
				//自己为左 node == parent->lchild
				right_rotate(proot,gp);
				gp->color = RED;
				parent->color = BLACK; 
			}else{//父为右   叔为左 
				if(node==parent->lchild){//自己为左 
					right_rotate(proot,parent);
					node = parent;
					parent = node->parent; 
				}
				//自己为右
				left_rotate(proot,gp);
				gp->color = RED;
				parent->color = BLACK; 
			}
			break;
		}
	}
	(*proot)->color = BLACK;  //根结点一定是黑色的 
} 
int rbtree_insert(RBTree *proot,ETYPE elem){
	struct RBNode **ptree = proot; //记录了根结点 
	struct RBNode *parent = NULL;
	while(*ptree != NULL){
		parent = *ptree;
		if(elem < (*ptree)->elem){
			ptree = &(*ptree)->lchild;
		}else if(elem > (*ptree)->elem){
			ptree = &(*ptree)->rchild;
		}else{
			return -1;
		}
	}
	*ptree = rbtree_create_node(elem,parent);
	if(*ptree == NULL){
		return -2;
	}
	//对红黑树进行修复 *proot是根结点  *ptree新插入的结点 
	rbtree_insert_repair(proot,*ptree);
	return 0;
}

static void rbtree_delete_repair(RBTree *proot,struct RBNode *parent,
	struct RBNode *node){
	//修复   相当于 parent 所指向的node结点方向删除了一个黑色结点
	//node结点必须兄弟结点 
	while(parent!=NULL && (node==NULL || node->color==BLACK)){
		//兄弟 
		struct RBNode *brother = parent->lchild==node?parent->rchild:parent->lchild;
		if(node == parent->lchild){//删除的是parent结点的左孩子 
			if(brother->color==RED){//case 1 兄弟为红    父为黑  兄弟的孩子为黑 
				brother->color = BLACK;
				parent->color = RED;
				left_rotate(proot,parent);
				brother = parent->rchild; 
			} 
			//兄弟为黑  且兄弟不存在红色的孩子 
			if(ISBLACK(brother)&&ISBLACK(brother->lchild)&&ISBLACK(brother->rchild)){
				if(parent->color==RED){//父结点为红色 
					parent->color = BLACK;
					brother->color = RED;
					break;//结束了 
				}else{//父结点是黑色的 
					brother->color = RED;
					node = parent;
					parent = parent->parent;
					continue; 
				} 
			}
			//兄弟存在红色的孩子
			if(ISBLACK(brother->rchild)){//远端侄子不是黑的  近端是红的 
				brother->color = RED;
				brother->lchild->color = BLACK;
				right_rotate(proot,brother);
				brother = brother->parent; 
			} 
			//远端的侄子是红色的
			brother->color = parent->color;
			parent->color = BLACK;
			brother->rchild->color = BLACK;
			left_rotate(proot,parent);
			break; 
		}else{//删除的是parent结点的右孩子 
			//兄弟为红
			if(brother->color == RED){
				parent->color = RED;
				brother->color = BLACK;
				right_rotate(proot,parent);
				brother = parent->lchild;
			} 
			//兄弟为黑
			if(ISBLACK(brother) && ISBLACK(brother->lchild) 
				&& ISBLACK(brother->rchild)){//1.兄弟儿子都为黑
			    if(parent->color == RED){ //   a.父结点为红
			    	parent->color = BLACK;
			    	brother->color = RED;
			    	break;
				}else{//   b.父结点为黑 
					brother->color = RED;
					node = parent;
					parent = node->parent;
					continue;
				}	
			}
			//2.兄弟儿子不全为黑
			//   a.远端为黑（近端为红） 
			if(ISBLACK(brother->lchild)){
				brother->color = RED;
				brother->rchild->color = BLACK;
				left_rotate(proot,brother);
				brother = brother->parent;
			}  
			//   b.远端为红 
			brother->color = parent->color;
			parent->color = BLACK;
			brother->lchild->color = BLACK;
			right_rotate(proot,parent);
			break;
		}
	} 
} 

static void rbtree_delete_node(RBTree *proot,struct RBNode **pnode){
	struct RBNode *node = *pnode;//node结点是要删除的结点 
	if(node->lchild==NULL && node->rchild==NULL){//叶子结点 
		if(node->color == RED){
			*pnode = NULL;
			free(node);
		}else{//删除黑色结点
			struct RBNode *parent = node->parent;//记录父结点 
			*pnode = NULL; 
			free(node);
			rbtree_delete_repair(proot,parent,NULL);//NULL表示删除的结点 
		}
	}else if(node->lchild!=NULL && node->rchild!=NULL){//有两个子树 
		//找左子树最大值 替换 当前结点的值  然后去删除左子树中的最大值 
		for(pnode=&(*pnode)->lchild;(*pnode)->rchild!=NULL;pnode=&(*pnode)->rchild);
		node->elem = (*pnode)->elem; //用左子树中的最大值来替换
		rbtree_delete_node(proot,pnode); //去删除左子树中的最大值结点 
	}else{//只有一个子树  且子树为红   node结点是黑的 
		*pnode = node->lchild!=NULL?node->lchild:node->rchild;
		(*pnode)->color = BLACK;
		(*pnode)->parent = node->parent;
		free(node); 
	} 	
} 
int rbtree_delete(RBTree *proot,ETYPE elem){
	RBTree *ptree = proot;//*proot
	while(*ptree != NULL){
		if(elem == (*ptree)->elem){
			rbtree_delete_node(proot,ptree);//删除*ptree结点 
			return 0; 
		}else if(elem < (*ptree)->elem){
			ptree = &(*ptree)->lchild;
		}else{
			ptree = &(*ptree)->rchild;
		}
	}
	return -1;
}


void rbtree_init(RBTree *proot){
	*proot = NULL;
}
bool rbtree_empty(RBTree root){
	return root == NULL;
}
size_t rbtree_size(RBTree root){
	if(root == NULL)
		return 0;
	return 1+rbtree_size(root->lchild)+rbtree_size(root->rchild);
}
size_t rbtree_hight(RBTree root){
	if(root == NULL)
		return 0;
	size_t lh = rbtree_hight(root->lchild)+1;
	size_t rh = rbtree_hight(root->rchild)+1;
	return lh>rh?lh:rh;
}

void rbtree_front_travel(RBTree root,void (*travel)(ETYPE,char)){
	if(root!=NULL){
		travel(root->elem,root->color);
		rbtree_front_travel(root->lchild,travel);
		rbtree_front_travel(root->rchild,travel);
	}
}
void rbtree_mid_travel(RBTree root,void (*travel)(ETYPE,char)){
	if(root!=NULL){
		rbtree_mid_travel(root->lchild,travel);
		travel(root->elem,root->color);
		rbtree_mid_travel(root->rchild,travel);
	}
}
void rbtree_back_travel(RBTree root,void (*travel)(ETYPE,char)){
	if(root!=NULL){
		rbtree_back_travel(root->lchild,travel);
		rbtree_back_travel(root->rchild,travel);
		travel(root->elem,root->color);
	}
}
void rbtree_clear(RBTree *proot){
	if(*proot != NULL){
		rbtree_clear(&(*proot)->lchild);
		rbtree_clear(&(*proot)->rchild);
		free(*proot);
		*proot = NULL;
	}
}
void rbtree_destroy(RBTree *proot){
	rbtree_clear(proot);
}



R-B tree 红黑树
特性：
每个结点或者黑色或者红色
根结点是黑色
每个叶子结点(NIL)是黑色      这里的叶子结点是不存在的结点，指为空 
如果一个结点是红色的，那么它的子结点必须是黑色的
即不能有两个连续的红色结点
从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点
最长的路径不大于最短路径的两倍（大致上是平衡的）

保证局部的平衡
夜卜.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
红黑树代码
03-30
红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树...
红黑树—rbtree
XuePH的博客
12-06 467
1、红黑树简介 红黑树（Red Black Tree）是一种重要的数据结构，大多数自平衡BST(self-balancing BST) 库函数都是用红黑树实现的，比如C++中的map 和 set （或者 Java 中的 TreeSet 和 TreeMap）。红黑树也用于实现 Linux 操作系统的 CPU 调度。完全公平调度（Completely Fair Scheduler）使用的就是红黑树 2、红黑树与AVL树（二叉平衡树）的比较： AVL树的时间复杂度虽然优于红黑树，但是对于现在的计算机
Day_21，红黑树及常用相关函数的实现
weixin_40301728的博客
06-07 238
假设有n个节点，普通二叉搜索树 O(h)可能存在 h=n的最坏情况；对于红黑树来说O(lgn)，不受这种h=n的限制 这里设置为RED可以不破坏性质5 #include <stdio.h> #include <string.h> #include <iostream> using namespace std; enum NodeColor { RED = 1, BLACK = 2 }; template<class T> clas.
HashMap中红黑树的查找函数find()实现
journey_fan的专栏
04-25 5002
//HashMap中红黑树的查找函数find()实现 /** * 调用树的find()函数 */ final TreeNode getTreeNode(int h, Object k) { return ((parent != null) ? root() : this).find(h, k, null);
红黑树详解（源码+图示）
lkn910907的专栏
01-23 759
Rbtree.h文件中数据结构及函数 rb_node 红黑树节点数据结构中使用成员rb_parent_color同时存储两种数据，一是其双亲结点的地址，另一是此结点的着色。__attribute__((aligned(sizeof(long))))属性保证了红黑树中的每个结点的首地址都是32位对齐的（在32位机上），也就是说每个结点首地址的bit[1]和bit[0]都是0，因此就可以使用bit
C++ STL标准库与泛型编程 （侯捷）（五）红黑树、Set、Map
Zy_05_11的博客
01-21 643
关联式容器，查找与元素的安插效率都很高，相当于一个小型的数据库（用 key 去寻找数据）。其底层实现是基于两个重要的技术：红黑树、散列表。 容器红黑树 原文：https://blog.csdn.net/SimonxxSun/article/details/85264200 key和data合成为value。图中举例时，只给定一个int，代表key和data是一致的。 标准库提供的函数id...
红黑树添加1111111
最新发布
09-29
红黑树添加
红黑树demo python代码
07-12
该资源是一个红黑树的demo程序，包含了红黑树的插入和红黑树的删除过程，实现方式相对比较简单明了，适合于刚刚接触红黑树的入门者阅读。
红黑树详解
09-02
红黑树详解（带目录源码） 本文适合那些有对二叉树有一定的基础，并且熟悉C语言的读者。本文最主要的参考资料是《Introduction to Algorithms 3rd Edition》。
红黑树的使用详解
09-05
本篇文章是对红黑树的使用详解。需要的朋友参考下
红黑树(一)之 原理和算法详细介绍
kk的博客
08-13 743
概要 目录1 红黑树的介绍2 红黑树的应用3 红黑树的时间复杂度和相关证明4 红黑树的基本操作(一) 左旋和右旋5 红黑树的基本操作(二) 添加6 红黑树的基本操作(三) 删除 作者：Sky Wang 于 2013-08-08 概述：R-B Tree，又称为“红黑树”。本文参考了《算法导论》中...
带你深入理解STL之RBTree
ZeeCoder
09-06 7766
最近一直忙于校招的笔试，STL的深入理解系列也耽搁了好几天，再加上！红黑树真的是超级超级难理解，超级超级复杂，参考了好多博客上的大神的理解才稍微明白一点，勉强入个门，下面请以一个菜鸟的角度跟着我一起学习STL的红黑树吧。概述红黑树是平衡二叉搜索树的一种，其通过特定的操作来保持二叉查找树的平衡。首先，我们来复习一下二叉查找树的知识，建议如果对二叉查找树不理解的先去搜一下相关博客来了解一下。二叉搜索树是
使用 vim + ctags + cscope + taglist + NREDtree阅读源码
AAA小肥杨的博客
07-23 415
最近，准备跟学长一起往 linux kernel 的门里瞧瞧里面的世界，虽然我们知道门就在那，但我们还得找到合适的角度才会看得更舒服，对吧^_^ 。        阅读源码的工具有很多，而且如今的集成开发环境（IDE）也很强大，但对于经常使用vim编辑器的程序员来说，对vim的强大绝对是“不抛弃，不放弃”的，况且我们只要安装一些插件配合vim的工作一样能达到IDE的效果，好了，废话少说。浏览了很...
C++进阶 STL(2) 第二天 一元/二元函数对象、一元/二元谓词、stack容器、queue容器、list容器(双向链表)、set容器、对组、map容器...
dglf54292的博客
04-04 229
01 上次课程回顾 昨天讲了三个容器 string string是对char*进行的封装 vector 单口容器 动态数组 deque(双端队列) 函数对象/谓词: 一元函数对象: for_each: 谓词: predicate 一元谓词: find_if 二元函数对象: transform ...
《算法导论》CLRS算法C++实现（十一）P163 红黑树
weixin_30323631的博客
06-15 73
第十三章 红黑树 首先说一下本章有一个地方的图有误，P168页的图，正确的图如下（case3有误，中文版）： 在Linux内核和STL中，都大量使用了红黑树这种数据结构，原因是红黑树的搜索、插入和删除效率都很高。 红黑树是一种二叉查找树，但在每个结点上增加一个存储位表示结点的颜色，可以是RED（红色）或BLACK（黑色）。 一棵红黑树有如下性质： （1）每个结点要么是红的，要...
redis到zset到红黑树
qq_32534441的博客
08-07 745
Redis熟悉么，了解哪些数据结构 说了zset zset底层怎么实现的 跳表 跳表的查询过程是怎么样的，查询和插入的时间复杂度 说了先从第一层查找，不满足就下沉到第二层找，因为每一层都是有序的，写入和插入的时间复杂度都是O(logN) 红黑树了解么，时间复杂度 说了是N叉平衡树，O(logN) 既然两个数据结构时间复杂度都是O(logN)，zset为什么不用红黑树 跳表实现简单，踩坑成本低，红黑...
三种平摊分析的方法分别为_平摊分析（算法导论）
weixin_39988779的博客
12-22 440
在平摊分析中，势能方法(potential method)不是将已预付的工作作为存在数据结构特定对象中存款来表示，而是表示成一 种“势能”或“势”，它在需要时可以释放出来，以支付后面的操作。势是与整个数据结构而不是其中的个别对象发生联系的。对一个初始数据结构D0 执行n个操作。对每个i，设ci为每个操作的实际代价，Di 为对数据结构Di-1执行第i个操作的结果. 势函数Φ 将每个数据结构Di 映射...
Ngx中的红黑树描述
一辈子太久只争朝夕的博客
09-24 209
红黑树 API接口 1 test_rbtree_init 2 test_rbtree_insert 3 test_rbtree_delete 4 回调函数 5 辅助函数 应用例子 1.红黑树五大特性: 1.节点是红色或黑色 2.根节点是黑色 3.所有叶子节点是黑色 4.每个红色节点的两个子节点都是黑色 5.从任意一个节点到其每个叶子节点的所有简单路径都包含相同数目的黑色节点 2.API接口结构体st
一步一图一代码，一定要让你真正彻底明白红黑树
热门推荐
结构之法 算法之道
01-09 8万+
          一步一图一代码，一定要让你真正彻底明白红黑树作者：July   二零一一年一月九日-----------------------------本文参考：I、  The Art of Computer Programming Volume III、 Introduction to Algorithms, Second EditionIII、The Annotated STL SourcesIV、 WikipediaV、  Algorithms In C Third Edition VI、 本
用C++实现一个红黑树
09-13
在插入节点时，我们需要按照二叉搜索树的规则找到插入位置，并进行一系列的旋转操作以保持红黑树的性质。 4. 实现节点的删除 节点的删除涉及到红黑树性质的调整，它不同于普通二叉搜索树的删除。在删除节点后，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值