红黑数学习

最新推荐文章于 2023-11-07 22:21:34 发布
最新推荐文章于 2023-11-07 22:21:34 发布
阅读量568 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wang_trace/article/details/78929934
版权

1. 红黑树的原则

1.每个节点要么是黑色，要么是红色

2.根节点必须是黑色

3.每个空的叶节点是黑色（NIL或者NULL）是黑色

4.新插入的节点是红色

5.红色节点不能连续（也就是，红色节点的孩子和父亲都不能是红色）（这个原则主要用于节点插入时树的调整）

6.每个节点，从任一节点到其nuLL的任何路径，都含有相同个数的黑色节点（也就是相同的黑色节点高度）



原则五的意思是任何一个子树，到null的黑色节点是相同的。（这个原则用于节点的删除时，对树的调整）


2. 红黑树的结构调整

红黑树的结构调整，主要是通过左旋或者右旋进行的。

2.1 左旋

被旋转的节点记为x，左旋就是将x节点的右孩子与x节点交换，左旋就是将x节点变为左节点。分为三步完成。

        (1) x节点的右孩子（xr）的左孩子（xrl）将变成x节点的右孩子（xr）

（2）x节点的右孩子（xr）成为x节点的父亲的孩子（也就是x与xr的交换）

（3）x节点成为其原右孩子的左孩子。





static void rotate_left(struct entry ** root, struct entry * x)
{
	struct entry * r = NULL;

	if((NULL != *root) &&(NULL != x)) {
		r = x->right; //1.保存x节点的右子树
		x->right = r->left;//2.x节点的右孩子换为其原来右子树的左孩子
		if(NULL != r->left)
			r->left->parent = x;//3.将x右子树的左孩子的父节点设为x ,这一步完成了
		//2,3两步完成了将x节点右子树的左孩子换为x节点的右子树
		
		r->parent = x->parent;//4.将x节点的父节点设为其右子树的父节点
		if(x->parent == NULL) {//5.说明x节点是跟节点，进行相关操作
			x->is_root = false;
			r->mod_count = x->mod_count;
			r->e_size = x->e_size;
			if(x->cmp != NULL)
				r->cmp = x->cmp;
			//上面5行完成了将根节点交接到r节点（x节点的右孩子）
			r->is_root = true;//设置r为根节点
			//r->color = BLACK;
			*root = r;
		} else if(x->parent->right == x) //6.x节点是右孩子，那么就将r节点设为x父节点的右孩子
			x->parent->right = r;
		else 
			x->parent->left = r;//7.x节点是左孩子，那么就将r节点设为x父节点的左孩子
		//4,5,6,7 这几步，主要完成x父节点与r的连接
		
		r->left = x;//8.r的左孩子为x
		x->parent = r;//9x的parent为r
		//8,9 这两个，完成将x节点设置为r节点的左孩子
		
	}
	
}

2.2 右旋

右旋跟左旋对应，右旋将x节点与x节点的左孩子交换，x节点将变为右节点。

（1）x节点的左孩子的右孩子（XLR）变为x的左孩子

（2）x节点的左孩子成为x节点父亲节点的孩子（也就是x节点与xL进行交换）

（3）x节点成为x原来左孩子的右孩子






static void rotate_right(struct entry ** root, struct entry * x)
{
	struct entry * l = NULL; 
	if((NULL != *root) && (NULL != x)) {
		l = x->left;//1.保存x节点的左子树，记为l
		x->left = l->right;//2.x节点的左孩子(l)的右孩子换为x的左孩子
		if(NULL !=l->right) 
			l->right->parent = x;//3.x节点的左孩子（l）的右孩子的父节点换为x
		//2,3步完成将x的左孩子的右孩子换为x的左孩子
		
		l->parent = x->parent;//4.x节点的左孩子的父节点，换为x的父节点
		if(NULL == x->parent) {//5.父节点为根节点
			x->is_root = false;
			l->mod_count = x->mod_count;
			l->e_size = x->e_size;
			if(x->cmp != NULL)
				l->cmp = x->cmp;
			l->is_root = true;
			//l->color = BLACK;
			*root = l;
		} else if (x->parent->right == x)//6.x是右孩子，则x左孩子成为x父节点的右孩子
			x->parent->right = l;
		else 
			x->parent->left = l;//7.x是左孩子，x左孩子成为x父节点的左孩子
		//4,5,6,7 几步完成了将x节点与x左孩子的对接
		
		l->right = x;//8.x成为x左孩子的右孩子
		x->parent = l;//9.x节点的父节点设置为x左孩子
		//8,9两步完成了将x设置为其左孩子的右孩子
	}
	
}

3.节点的插入

节点插入，新加入的节点是红色，所以如果父节点是红色的话，违反红黑树的原则5（红色节点不得连续），这时需要根据情况进行相关节点的颜色调整或者树的结构进行调整。

有以下的三种情况。

        情况一：被插入的节点是根节点

        处理方法：直接把此节点涂为黑色


情况二：被插入的节点的父节点是黑色

处理方法：什么都不需要做，因为插入是红色，父节点是黑色，仍然满足红黑树


情况三：被插入的节点的父节点是红色

处理方法：颜色调整或结构调整

调整的原则是:先调颜色后调结构

从树末（新加入点）到树根的调整，即先把先加入的父父节点为根的小树调整为满足规则，在按相同的规则逐一往上进行调整。

1）.叔父节点为红色时，进行颜色调整（将父辈（父亲和叔父），以及祖父辈的颜色翻转），此时小树满足颜色要求，就将新加入的x节点转为为祖父节点，查看祖父节点所在的小树是否满足红黑颜色调整。

2）颜色调整的结束条件是叔父节点为黑色，此时颜色已经满足要求，调整树的结构来达到平衡（满足其他的要求）

3）结构调整的原则

A.x节点与父节点有相同的结构属性（比如都是左孩子或者都是右孩子）：进行一种旋转

需要根据x节点的结构属性（左或者右）对x的祖父节点进行旋转

B.x节点与父节点的结构属性不相同（x是左，p是右）：进行两种旋转

根据x的结束属性的相反值，对父节点进行旋转，并且x转为x的父节点

进行A情况的旋转。



  上图从截取：http://www.cnblogs.com/CarpenterLee/p/5503882.html

static void fix_after_insertion(struct entry ** root, struct entry * x)
{
	struct entry * p = NULL;
	struct entry * pp = NULL;
	struct entry * ppr = NULL;
	struct entry * ppl = NULL;
	while((NULL != x) && (!(x->is_root)) && (x->parent->color == RED)) {
		p = x->parent; //父节点
		pp = p->parent;//父父节点
		ppr = pp->right;//父父节点的右孩子
		ppl = pp->left;//父父节点的左孩子

		if(p == ppl) {//父节点是父父节点的左孩子
			if((NULL != ppr) && (ppr->color == RED)) {//情况一:叔父节点为红色时，将上两极的颜色翻转,x换为pp
				p->color = BLACK;	//父节点设置为黑色
				ppr->color = BLACK;	//叔父节点设置为黑色
				pp->color = RED;	//父父节点设置为红色
				x = pp;	//x转为父父节点
			} else {//叔父节点为空，或者为黑色
				if(x == p->right) {//情况二:x与p的结构属性不同，按照p进行左旋
					x = p;
					rotate_left(root, x);//进行左旋
				}
				//情况三：按照祖父节点进行右旋
				x->parent->color = BLACK; //父节点为黑色
				x->parent->parent->color = RED;//父父节点为红色
				rotate_right(root, x->parent->parent);//进行右旋
			}
		} else {//父节点是父父节点的右孩子
			if((ppl != NULL) && (ppl->color == RED)) {//叔父节点为红色时，将上两极的颜色翻转
				p->color = BLACK;//父节点设为黑色
				ppl->color = BLACK;//叔父节点设为黑色
				pp->color = RED;//父父节点设为红色
				x = pp;//x换为父父节点
			} else {//叔父节点为黑色
				if(x == p->left) {//x是左孩子，需要进行右旋
					x = p;
					rotate_right(root, x);
				}
				x->parent->color = BLACK;//x的父节点为黑色
				x->parent->parent->color = RED;//x的父父节点为红色
				rotate_left(root, x->parent->parent);//x的父父节点左旋
			}
		}
	}
	
	(*root)->color = BLACK;//设置跟节点为黑色
}
static void * put(struct entry ** root, void * key, void * data)
{
	struct entry * t = *root;
	struct entry * tt = *root;
	struct entry * r = NULL;
	struct entry * x;
	int cmp = 0;
	if(NULL == t) {//根节点为空，创建一颗树
		printf("is null!\n");
		r = entry_new(key, data);
		r->is_root = true;
		r->color = BLACK;
		r->mod_count++;
		r->e_size++;
		*root = r;
		return NULL;
	}
	//这个比较函数没有通过函数的方式进行赋值，可以再根节点创建后进行赋值
	if(NULL ==(*root)->cmp)
		(*root)->cmp = default_cmp;
	//如果键值已经存在，则重置键值	
	do {	
		x = t;
		cmp = (*root)->cmp(key,x->key);
		if(cmp > 0)
			t = t->right;
		else if (cmp < 0)
			t = t->left;
		else
			return set_value(t, data);
	} while(t != NULL);
	//键不存在在新建节点
	r = entry_new(key, data);
	//r->root = *root;
	if(cmp < 0)
		x->left = r;
	else 
		x->right = r;
	r->parent = x;
	
	tt->mod_count++;
	r->e_size++;
	
	fix_after_insertion(root, r);
	return NULL;
	
}


4.获得最小或最大节点

因为红黑树是一颗有序树，树的左边总是小于树的右边。因此只要找到左节点，就是整颗树的最小值，找到整颗树的最右边，就是整棵树的最大值。

/*
*	寻找最左边的孩子，也就是整棵树的最小值的节点
*/
static struct entry * entry_node_first(struct entry * root)
{
	struct entry * nl;
	nl = root;
	if(!nl)
		return NULL;
	while(nl->left)
		nl = nl->left;
	return nl;
}
/*
*	寻找最右边的孩子，也就是整棵树的最大值的节点
*/
static struct entry * entry_node_last(struct entry * root)
{
	struct entry * nr;
	nr = root;
	if(!nr)
		return NULL;
	while(nr->right)
		nr = nr->right;
	return nr;
}

5.节点的删除

节点删除后，容易造成黑色节点的高度不同。因此节点删除时树结构调整的总原则是：如果被删除的节点是黑色，需要进行调整。

           节点的删除有以下几种情况：被删除的节点记为D

（1）被删除节点没有孩子（也就是叶子节点），被删除的叶子节点是黑色时，进行树结构的调整，然后直接将该节点删除

         （2）被删除节点只有一个孩子，那么直接删除该节点，并用该节点的唯一子节点替换它。如果替换的节点是黑色，进行树结构的调整

          （3）被删除节点有两个孩子，先找到该节点的替换节点（被删除节点的左子树的最左节点），此时被删除的节点变为了替换节点（替换节点的键和值拷贝到被删除的节点，需要将替换的节点删除掉），如果替换节点为黑色，进行树结构的调整。

/*
*	找到删除节点的继承者
*	原则：当删除节点存在左和右节点的时候，需要寻找
		且继承者是其右孩子或者右孩子的最左孩子
*	从删除函数中可知，找到的后继者肯定都是右子树的最左孩子
*/
static struct entry * successor(struct entry * x)
{
	struct entry * p= NULL;
	struct entry * ch = NULL;
	if(NULL == x)
		return NULL;
	else if(x->right != NULL) {//1.x 的右子树不为空，则t的后继是其右子树中最小的那个元素
		p = x->right;
		while(p->left != NULL)
			p = p->left;
		return p;
	} else {//2. x的右子树为空，则t的后继是其第一个向左走的祖先
		p = x->parent;
		ch = x;
		while(p != NULL && ch == p->right) {
			ch = p;
			p = p->parent;
		}
		return p;
	}
}


 

static void delete_entry(struct entry ** root, struct entry * p)
{
	struct entry *s = NULL;
	struct entry *replace = NULL;
	struct entry * r = *root;
	struct entry * node = *root;
	r->e_size--; //树中节点的个数
	r->mod_count++;//树的修改次数
	printf("tree->key:%ld, tree->data:%ld, is_root:%d, size:%d, color:%d\n", (long)p->key, (long)p->data, p->is_root, (*root)->mod_count, p->color);
	if((p->left != NULL) && (p->right != NULL)) {//(3).删除点p的左右子树都非空,这个情况会最终转换为删除叶子节点
		s = successor(p);//继承者是右孩子的最左子孙
		//使用继承者替换要删除的节点
		p->key = s->key;
		p->data = s->data;
		//上面两步是找到继承者之后，替换key和value
		p = s;//将继承者赋值为p，进行后续的处理
		printf("tree->key:%ld, tree->data:%ld, is_root:%d, size:%d, color:%d\n", (long)p->key, (long)p->data, p->is_root, (*root)->mod_count, p->color);
	}
	//如果p有左孩子则取左孩子，否则取右孩子
	replace = (p->left != NULL ? p->left : p->right);
	
	if(replace != NULL) {//(2).删除点只有一个子树非空 

		
		replace->parent = p->parent;
		if(p->parent == NULL) {//p节点没有父节点，则p是父节点
			p->is_root = false;
			replace->mod_count = p->mod_count;
			replace->e_size = p->e_size;
			if(p->cmp != NULL)
				replace->cmp = p->cmp;
			replace->is_root = true;
			replace->color = BLACK;
			*root = replace;
		} else if(p = p->parent->left) {//删除p的父节点到p的引用
			p->parent->left = replace;
		} else 
			p->parent->right = replace;
		p->left = p->right = p->parent = NULL;//解除p的左右节点以及父节点的引用
		if(p->color == BLACK)
			fix_after_deletion(root, replace);
	} else if(p->parent == NULL) {//(4):如果一个节点没有左右节点以及父节点，则说明是根节点，也就是只有一个节点
			*root = NULL;
	} else {//(1)被删除的节点是叶子节点

		if (p->color == BLACK)
            fix_after_deletion(root, p); //根据
		
		if(p->parent != NULL) { 
			if(p == p->parent->left)
				p->parent->left = NULL;
			else if(p == p->parent->right)
				p->parent->right = NULL;
			p->parent= NULL;
		}
	} 
	
	if(p)
		free(p);	
}

删除时的结构调整，有如下几种情况

1）兄弟节点是红色（说明父节点肯定黑色，且兄弟的孩子都是黑色）

2）兄弟节点是黑色，且兄弟节点的两个子节点都是黑色

3）兄弟节点是黑色，且兄弟节点的左子节点为红色，右子节点为黑色

4）兄弟节点是黑色，且兄弟节点的右子节点为红色，左子节点任意色

2）3）4）三种情况是兄弟节点为黑色时的子集。

情况一：当前节点是黑色，且兄弟节点是红色（此时父节点和子节点肯定是黑色的）

处理办法：将父节点和兄弟节点颜色翻转，并按照父节点进行旋转（旋转的方向与当前节点的结构属性相同（左孩子向左，右孩子向右）），调整之后，树变有了2）3）4）的属性特点了



情况二：兄弟节点是黑色，且兄弟节点的子节点都是黑色

处理办法：将兄弟节点颜色翻转，然后将当前节点设为父节点，开始新一轮的颜色检查



情况三：兄弟节点为黑色，它的左子节点为红色（或者不存在），它的右子节点为黑色。（此情况调整之后，必然要走情况四）

处理办法：A.将兄弟节点及其孩子的颜色翻转;B.按照兄弟节点进行旋转（旋转的方向与当前节点的结构属性相反（当前节点为左节点，则右旋，反之亦然））C.旋转后，从新设置兄弟节点


           


情况四：兄弟节点是黑色，兄弟孩子的右孩子（左孩子）是红色，左孩子任意

处理办法：

      A.兄弟节点的颜色为父节点颜色

B.父节点以及右节点（或左节点）设置为黑色

        c.按照父节点进行旋转（旋转方法与节点的结构属性相同（左节点往左旋，反之亦然））

        d.当前节点设置为根节点（意味着结束调整）



从以上的特点可以看出，如果是情况一，那么可能出现2,3,4的情况。如果是情况二，那么需要进行新一轮的情况检查后并做相关的操作。如果是情况3，那么必然出现情况四，如果二和三都不是，那么必然是四。

static void fix_after_deletion(struct entry ** root, struct entry * x)
{
	struct entry * node = NULL;
	while(x && (x != *root) && (x->color == BLACK)) {
		if(x == x->parent->left) { //x是左孩子
			node = x->parent->right;
			if(node && node->color == RED) {//如果右孩子是红色，此时父节点肯定是黑色
			/*
			*	删除节点是黑色，兄弟节点为红色
			*	兄弟节点和父节点的颜色翻转
			*	将父节点进行左旋
			*	交换后x的父节点不变，但是其父节点的右孩子变为父节点原来右孩子的左孩子
			*/
				node->color = BLACK;			
				x->parent->color = RED;
				rotate_left(root, x->parent);
				node = x->parent->right;
			}
			
			if(node->left && node->left->color == BLACK && node->right && node->right->color == BLACK) {
				/*
				*	此时，x为黑，x的兄弟为黑，x的兄弟的黑子都是黑
				*	将x的兄弟设为红色
				*	x转移到x的父节点
				*/
				node->color = RED;
				x = x->parent;
			} else {
				if(node->right && node->right->color == BLACK) {
					/*
					*	此时左边为红色，右边为黑色
					*	将左右两边的颜色翻转
					*	右旋后
					*/
					if(node->left)
						node->left->color = BLACK;
					node->color = RED;
					rotate_right(root, node);
					node = x->parent->right;
				}
				node->color =x->parent->color;
				x->parent->color = BLACK;
				node->right->color = BLACK;
				rotate_left(root, x->parent);
				x = *root;
			}
		} else {
			node = x->parent->left;
			if(node && node->color == RED) {
				node->color = BLACK;
				x->parent->color = RED;
				rotate_right(root, x->parent);
				node = x->parent->left;
			}
			if(node->right && node->right->color == BLACK && node->left && node->left->color == BLACK) {
				node->color = RED;
				x = x->parent;
			} else {
				if(node->left && node->left->color == BLACK) {
					if(node->right)
						node->right->color = BLACK;
					node->color = RED;
					rotate_left(root, node);
					node = node->parent->left;
				}
				
				node->color = x->parent->color;
				x->parent->color = BLACK;
				node->left->color = BLACK;
				rotate_right(root, x->parent);
				x = *root;
			}
		}
	}
	x->color = BLACK;
}


图截取于http://www.cnblogs.com/CarpenterLee/p/5525688.html

6.树的遍历

 红黑树是二叉平衡的有序树，因此可以采用从根节点开始分为左边遍历以及右边遍历，也就是找到树的最小节点或者最大节点，然后根据下一节点进行遍历。

/*
*	查找左边的下一个
*/
static struct entry * entry_node_next(struct entry * root)
{
	struct entry * parent;
	struct entry * r = root;

	if(!root->parent) {//如果是根节点，返回
		return NULL;
	}
	
	if(r->right) {//
		r = r->right;
		while (r->left)
			r = r->left;
		return r;		
	}
	
	while((parent = r->parent) && r == parent->right)//从最后一个叶子节点找到根节点
		r = parent;
	
	return parent;
}
/*
*	查找右边的下一个
*/
static struct entry * entry_node_prev(struct entry * root)
{
	struct entry *parent;
	struct entry * node = root;

	if(!root->parent)
		return NULL;
	
	if(node->left) {
		node = node->left;
		while(node->right)
			node = node->right;
		return node;
	}
	
	while((parent = node->parent) && node == parent->left)
		node = parent;
	return parent;
}

遍历函数

 

static void print_the_tree(struct entry * root)
{
	struct entry * node = NULL;
	//左边的树
	for(node = entry_node_first(root); node != root; node = entry_node_next(node)) {
		printf("node->key:%ld, node->data:%ld, is_root:%d, color:%d\n", (long)node->key, (long)node->data, node->is_root, node->color);
	}
	//右边的树
	for(node = entry_node_last(root); node != root; node = entry_node_prev(node)) {
		printf("node->key:%ld, node->data:%ld, is_root:%d, color:%d\n", (long)node->key, (long)node->data, node->is_root, node->color);
	}
	printf("root->key:%ld, root->data:%ld, is_root:%d, size:%ld, color:%d\n", (long)root->key, (long)root->data, root->is_root, root->e_size, root->color);
}

 
















wang_trace
关注
红黑树学习
jiqiren1994的博客
09-14 376
一、红黑树简介 1972年Rudolf Bayer发明，称为平衡二叉B树（symmetric binary B-trees），在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为“红黑树”，一种特化的AVL树，在插入和删除时通过特定操作保持二叉查找树的相对平衡，从而获得较高的查找性能。 红黑树不是严格的AVL树，只是黑色平衡，如上图所示，根结点P的左子树显然比右子树高，但左子树和右子树的黑结点的层数是相等的。 二、红黑树特点 符合二叉搜索树基本特性，同时具备以下特性：
二叉树进阶之红黑树超详细讲解
wer24_25的博客
09-21 1992
二叉树进阶之红黑树超详细讲解,感兴趣的宝子们赶紧点赞收藏起来吧!!!
红黑树深入学习
weixin_41090596的博客
05-31 99
一、介绍 红黑树是一种特殊的二叉查找树（特殊在自平衡上），每个节点会存储本节点的颜色，根节点和叶子节点(NIL或NULL，叶子结点不存储数据)是黑色。从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点（确保没有一条路径 会比其他路径长出两倍）。 应用场景：主要用来存储有序的数据，时间复杂度为O(lgn)。Java集合中的TreeSet和TreeMap，C++STL中的set、map以及Linux虚拟内存的管理都是通过红黑树实现 对于频繁插入、删除的场景，红黑树优势明显 二、自平衡实现 左
红黑数学习笔记
weixin_33849942的博客
11-27 257
红黑树介绍 红黑数一种为了实现平衡二叉树的数据结构(因为二叉树在最坏的情况下时间复杂度等于线性的复杂度)，红黑数的时间复杂度O(lgn)，最坏情况也是如此。 红黑书需要满足五点性质： 1.所有节点只能是黑色或者红色 2.根结点必定为黑色 3.所有叶子节点(NIL或者null)必为黑色 4.红节点的子节点必为黑色 5.树种任意的一个节点到其所有叶子的节点的路径黑色节点的数量都是一样的 ...
红黑树的插入创建(左旋 右旋)
Below_Crusder的博客
07-06 2219
红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。除了二叉查找树的性质，同时还有以下的五大性质： 性质1. 节点是红色或黑色。 性质2. 根节点是黑色。 性质3 每个叶节点（NIL节点，空节点）是黑色的。 性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点到其每个叶子的所有路径都包含相同数
红黑树的理解与学习&左旋与右旋操作
fuqiaoyimeng的专栏
10-08 3905
http://zh.wikipedia.org/wiki/%E7%BA%A2%E9%BB%91%E6%A0%91#.E7.94.A8.E9.80.94.E5.92.8C.E5.A5.BD.E5.A4.84
红黑数原理及存在原因
ljjjjjjjjjjj的博客
11-07 261
所以就考虑到，能不能找到一种数据结构，即满足查询快，又满足增删快？有，就是二叉搜索树，搜索就是二分查找的思路，小于当前节点的往左子树找，大于节点的往右子树找。增删就通过左右子树增删数据。这个时候就需要红黑树出场了，它会对如上不平衡的结构进行处理，将一些节点移动到左边，在保证搜索效率的同时，还能保证增删的效率。相比之下，链表的插入和删除就很简单，时间复杂度是O(1)，但是它查询速度慢，时间复杂度为O(N)。但是，如果增加的数据一直挂在右子树或者左子树上，二叉搜索树就变成了一个单链表，查找效率就递减。
设计模式学习纪录，另外包含了基础排序算法，红黑数自己实现，LRU，LFU等算
最新发布
09-26
基础排序算法则是算法学习的起点，而红黑树、最近最少使用（LRU）和最不常使用（LFU）缓存算法则是数据结构和算法在实际应用中高效处理数据的体现。 首先，设计模式涉及软件设计中常见问题的解决方案。它们被分为...
红黑树 学习总结
05-09
红黑树是一种近AVL树。具有以下性质： 1）结点非红即黑； 2）根节点必须为黑色； 3）任意从根到叶子的路径不包含连续的红色节点； 4）从任意结点到其所有叶子结点的路径中，包含相同的黑色结点个数。
红黑树 学时PPT学习教案.pptx
10-11
节点数n满足n≥2r-1，确保至少是满二叉树；高度h≤2log2(n+1)。 3. **红黑树操作的时间复杂度**： - 红黑树的插入、删除和查找操作的时间复杂度都为O(logn)，这得益于其平衡性。 4. **红黑树的插入**： - 插入新...
红黑树
11-08 1907
红黑树是一种很有意思的平衡检索树。它的统计性能要好于平衡二叉树(有些书籍根据作者姓名，Adelson-Velskii和Landis，将其称为AVL-树)，因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。红
红黑树特征和翻转操作
xiaoqiang_0719的博客
05-08 2176
红黑树特征： 红黑树是每个节点都带有颜色属性的二叉查找树 性质1. 节点是红色或黑色。 性质2. 根节点是黑色。（最顶端的中间节点为根节点） 性质3 每个叶节点（NIL节点，空节点）是黑色的。 性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 红黑树的左旋操作 ...
红黑树（Red Black Tree，RBTree）
qq_39918677的博客
09-15 8861
一、概念 红黑树是一种自平衡二叉查找树（二叉排序树）。与平衡二叉树（avl树）不同的是，红黑树是弱平衡二叉树，即它的左右子树高度差有可能大于1。 二、5大性质 每个节点要么是黑色, 要么是红色。 根节点是黑色。 每个叶节点(Nil，空值)都是黑色。 每个红色节点的两个子节点一定都是黑色。 任意一个节点到每个叶子节点的路径都包含相同数量的黑节点。 三、推论（或规律） 左子树和右子树的黑节点的层数是相等的。因此我们称红黑树的这种平衡为黑色完美平衡。（由性质5推出） 如果一个节点存在黑子节点，那么该节点肯定
三句秘诀搞定红黑树的旋转变换
awodwde的博客
12-07 1151
红黑树的性质 1、每个节点不是红色就是黑色 2、不可能有连在一起的红色节点（这个性质后面要用，其他性质看一遍就够了） 3、根节点都是黑色的（什么是根节点：父节点为null，或者入度为0） 4、每个红色节点的两个子节点都是黑色。叶子节点都是黑色（每个节点最后都是有NL节点，只是没有画出来） 画出来就是这个下面的样子 先来熟悉一下左旋操作： 只看E和S，就是将S移动上去，E点移动下来，再将S的左节点变成E点的右节点 左旋看懂了，再来看看右旋操作： 先看总结的文...
红黑树（2）—— 红黑树颜色翻转和右旋转
一角残叶的博客
02-12 901
3 颜色翻转和右旋 3.1 颜色翻转（flipcolors） RBTree.java package tree; public class RBTree&amp;lt;K extends Comparable&amp;lt;K&amp;gt;, V&amp;gt; { private static final boolean RED = true; private static final bool...
查找（一）史上最简单清晰的红黑树讲解
热门推荐
菜鸟的自留地-mooyang
05-18 13万+
查找（一） 我们使用符号表这个词来描述一张抽象的表格，我们会将信息（值）存储在其中，然后按照指定的键来搜索并获取这些信息。键和值的具体意义取决于不同的应用。 符号表中可能会保存很多键和很多信息，因此实现一张高效的符号表也是一项很有挑战性的任务。 我们会用三种经典的数据类型来实现高效的符号表：二叉查找数、红黑树、散列表。 二分查找 我们使用有序数组存
红黑树旋转变色规则（最全面详细版）
PANDA博客
12-07 9288
一、红黑树性质 结点必须是红色或者黑色。 根节点必须是黑色。 叶节点(NIL)必须是黑色(NIL节点无数据，是空节点)。 红色结点不能连续。 从任一节点出发到其每个叶子节点的路径，黑色节点的数量必须相等。 二、旋转变色规则 已知插入根节点涂为黑色，其他节点都是涂红色；如果插入结点的父节点为黑色，就不需要进行旋转变色调整，其他情况都需要根据实际选择合适的处理策略进行调整，使其符合红黑树性...
红黑树系列一：旋转
sophiaFXR的博客
12-02 3700
红黑树系列一：旋转 红黑树一棵在每个结点上增加了一个存储位来表示结点颜色（红色RED或黑色BLACK）的二叉搜索树。 二叉搜索树简单的说就是：对树中任何结点x，其左子树中的关键字最大不超过x.key，即对左子树中任一结点y，有y.key；其右子树中的关键字最小不低于x.key，即对右子树中任一结点y，有y.key>x.key。 红黑树中每个结点包含5个属性：col
红黑树旋转规则
weixin_42769116的博客
12-26 2889
红黑旋转规则 新插入的节点如果是外部孙子，则进行单旋转，如下图。 如果先插入的节点是内部孙子，则进行双旋转，如下图。 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示...
C++实现随机数构造红黑树
本文档提供了一个使用C++实现根据随机生成的数构造红黑树的代码示例。红黑树是一种自平衡二叉查找树，它的每个节点包含一个颜色属性，可以是红色或黑色，以此来确保树的性质。代码中包含了随机数生成、红黑树插入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值