红黑树的解析与实现

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

红黑树

   上一篇中讲到，一棵高度为h的二叉搜索树，它所进行的操作都可以在O(h)时间内完成。因此搜索树的高度较低时，可以较快的完成。但是，如果树的高度较高时，这些集合操作可能并不比链表上快。如何实现一种搜索树的结构，使得其任何一种基本操作都可以在O(lgn)的时间内完成呢？

    红黑树，就是这种“平衡”搜索树中的一种。可以保证最坏的情况下，基于动态集合操作的时间复杂度为O(lgn)。

    红黑树，也是一种二叉搜索树，也支持search, predecessor, successor, minimum, maximum, insert 和 delete等操作，但是却有着和普通二叉搜索树不同的性质，于是也导致它的某些操作的复杂性，但是以code的复杂度换取时间的复杂度，不亦乐乎。

   下面开始一起走入红黑树吧：

    1、性质：

     (1)每个结点要么是红色，要么是黑色；

     (2)根结点是黑色的;

     (3)每个叶子结点是黑色的。

     (4)如果一个结点是红色的，则它的两个子结点都是黑色的。

     (5)对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。

                    

    


     2、准备知识  --->旋转
     搜索树在insert 和 delete的时候可能违反它的一些性质，因此必须改变某些结点的颜色和指针，以维持它的性质不变。指针的修改便是通过“旋转"来完成的。
     （1）左转
  
Left_Rotate( T, x)

y = x.right
x.right = y.left
if y.left != T.NIL
   y.left.p = x
y.p = x.p
if x.p = T.NIL
   T.root = y
else if x = x.p.left
   x.p.left = y
else
   x.p.right = y
y.left = x
x.p = y

右转可以对称来实现。

3、插入
  我们可以依据普通二叉搜索树的insert过程插入一个新的结点z, 并将其着为红色（为了尽量避免对红黑树进行调整）。看看插入新的结点z后对它的性质有什么影响：
   （1）如果插入的是根结点，则违背了性质2，简单地将其着为黑色即可。 
   （2）如果插入结点后，它的父结点是红色，则违背了性质4，针对这种情况的调整方案分析如下：
  
   

   4、删除
        删除一个结点，延用普通二叉搜索树的删除方案：
        若要删除的结点，它有非双空子结点，则可以直接删除该结点，让它的唯一子结点指向它。若子结点都为空，则用NULL取代原来的结点。若子结点均非空，则用它的后继结点的值取代它的值，然后以同样的方式删除它的后继结点即可。（所以，要删除的结点是z,那么实际删除的是它的后继结点y,而这么一个删除的过程是一个递归过程，慢慢体会吧）
        但是在删除节点后，原来红黑树的性质可能被改变，如果被删除的结点是红色的结点，那么一切OK。如果被删除 结点是黑色的话，可能就会破坏它的某些性质：
        （1）如果要删除的结点不是唯一的树结点，那么从它为根结点，到各个支路的黑高可能会受到影响，从而破坏性质5
        （2）如果被删除的结点是根结点，而它的唯一子结点是红色，则破坏了性质1.
   如下，是我在纸张画的分析过程，直接贴上来：
  

  
至此已分析完毕。贴上实现的代码： 
// RB_Tree_.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;

enum Color
{
	Black,
	Red
};

typedef struct RB_Node
{
	Color color;
	int key;
	struct RB_Node *left;
	struct RB_Node *right;
	struct RB_Node *p;
}RB_Node, *p_RB_Node;

RB_Node *T_NULL = NULL;
RB_Node * FindNode(RB_Node *root, int k)
{
	while(root!=NULL && k!=root->key)
	{
		if(k<root->key)
			root = root->left;
		else 
			root = root->right;

	}
	if(root == NULL)
		return NULL;
	else 
		return root;

}

RB_Node * RB_Tree_Minimum(RB_Node *x)
{
	RB_Node *y = T_NULL;
	while(x!=T_NULL)
	{
		y = x;
		x = x->left;
	}
	return y;
}

RB_Node * Succssor(RB_Node *root, RB_Node *x)
{
	if(x->right !=T_NULL)
		return RB_Tree_Minimum(x->right);
	RB_Node *y = x->p;
	while(y!=T_NULL && x == y->right)
	{
		x = y;
		y = y->p;
	}
	return y;
}

void Left_Rotate(p_RB_Node *root, RB_Node *x)
{
	RB_Node *y = x->right;
	x->right = y->left;
	if(y->left!=T_NULL)
		y->left->p = x;
	y->p = x->p;
	if(x->p == T_NULL)
		*root = y;
	if(x == x->p->left)
		x->p->left = y;
	else
		x->p->right = y;
	y->left = x;
	x->p = y;
}

void Right_Rotate(p_RB_Node *root, RB_Node *x)
{
	RB_Node *y = x->left;
	x->left = y->right;
	if(y->right != T_NULL)
		y->right->p = x;
	y->p = x->p;
	if(x->p ==T_NULL)
		*root = y;
	if(x == x->p->left)
		x->p->left = y;
	else
		x->p->right = y;

	y->right = x;
	x->p = y;
}

void RB_Insert_FixUP(p_RB_Node *root, RB_Node *z)
{
	/*
	1.z是要插入的节点，p是其父节点，G是祖父节点，W是叔父节点；存在两种情况：p = G.left and p = G.right
	注意破坏的是什么性质，去fix的是什么性质。
	*/
	while(z->p->color == Red)
	{
		RB_Node *p = z->p;
		RB_Node *G = z->p->p;
		RB_Node *W = T_NULL;
		if(p == G->left)
		{
			W = G->right;
			//case 1:z的父节点p和叔父节点W均是红色，那么G一定是黑色，则将p和w均着为黑色，将G着为红色
			if( W->color ==Red)
			{
				p->color = Black;
				W->color = Black;
				G->color = Red;
				z = G;
			}
			//case 2:w是黑色，且z是其父节点的右孩子，那么将p作为当前节点，并以它为支点，左旋
			else if(z == p->right)
			{
				z = p;
				Left_Rotate(root,p);
			}
			//case 3:w是黑色，z是p的左孩子，将p,G的颜色交换，然后以G为支点，右旋。
			else
			{
				p->color = Black;
				G->color = Red;
				Right_Rotate(root,G);
			}
		}

		else
		{
			W = G->left;
			if( W->color ==Red)
			{
				p->color = Black;
				W->color = Black;
				G->color = Red;
				z = G;
			}
			else if(z == p->left)
			{
				z = p;
				Right_Rotate(root,p);
			}
			else
			{
				p->color = Black;
				G->color = Black;
				Left_Rotate(root,G);
			}
		}
	}
	(*root)->color = Black;
}

void RB_Insert(p_RB_Node *root, int k)
{
	RB_Node *x = *root;
	RB_Node *z = new RB_Node;
	RB_Node *temp = T_NULL;
	z->color = Red;
	z->key = k;
	z->left = z->right = z->p = T_NULL;
	while(x!=T_NULL)
	{
		temp = x;
		if(k<x->key)
			x = x->left;
		else 
			x = x->right;
	}
	z->p = temp;
	if(temp == T_NULL)
		*root = z;
	else if(k<temp->key)
		z->p->left = z;
	else
		z->p->right = z;
	if(z->p==T_NULL)
		z->color = Black;
	else
		RB_Insert_FixUP(root,z);
	//delete z;
}

void RB_Delete_Fixup(p_RB_Node *root, RB_Node *x)
{
	while(x!=(*root)&& x->color != Red)
	{
		RB_Node *p = x->p;
		RB_Node *w = T_NULL; //w为x的兄弟节点
		if(x == p->left)
		{
			w = p->right;
			//case 1: 兄弟w 为红色，那么p一定是黑色，p与w换颜色，然后以p 为支点左旋
			if(w->color == Red)
			{
				w->color = Black;
				p->color = Red;
				Left_Rotate(root,p);
			}
			//case 2: 兄弟为黑色，且兄弟的两孩子也均为黑色，分别提取x和w的一层黑，加到p上，以p作为新的x 结点，继续递归
			if(w->left->color == Black && w->right->color == Black)
			{
				w->color = Red;
				p->color = Black;
				x = p;
				
			}
			//case 3:兄弟为黑色，左孩子为红色，右孩子为黑色。
			//w与w.left交换颜色，然后以w为支点右旋---->到达case 4
			else if(w->left->color == Red && w->right->color == Black)
			{
				w->left->color = Black;
				w->color = Red;
				Right_Rotate(root,w);
			}
			//case 4:兄弟为黑色，右孩子为红色，左孩子任意。
			//w着为p的颜色，p着为黑色，兄弟右子结点染黑。然后以p为支点左旋，最终恢复红黑树的性质
			else if(w->right->color == Red)
			{
				w->color = p->color;
				p->color = Black;
				w->right->color = Black;
				Left_Rotate(root,p);
				x =(*root);
			}
		}
		else
		{
			w = p->left;
			if(w->color == Red)
			{
				w->color = Black;
				p->color = Red;
				Right_Rotate(root,p);
			}
			if(w->left->color == Black && w->right->color == Black)
			{
				w->color = Red;
				p->color = Black;
				x = p;

			}
			else if(w->right->color == Red && w->left->color == Black)
			{
				w->right->color = Black;
				w->color = Red;
				Left_Rotate(root,w);
			}
			else if(w->left->color == Red)
			{
				w->color = p->color;
				p->color = Black;
				w->left->color = Black;
				Right_Rotate(root,p);
				x = (*root);
			}
		}
	}
	(*root)->color = Black;
}

void RB_Delete_Node(p_RB_Node *root, int k)
{
	//z是要删除的节点，y是实际上被删除的节点，x是y节点的孩子
	RB_Node *z = FindNode(*root,k);
	RB_Node *y = T_NULL;
	RB_Node *x = T_NULL;
	if(z->left == T_NULL && z->right == T_NULL)
		y = z;
	else
		y = Succssor(*root,z);
	if(y->left !=T_NULL)
		x = y->left;
	else 
		x = y->right;
	x->p = y->p;
	if(x->p == T_NULL)
		*root = x;
	else if(y == y->p->left)
		y->p->left = x;
	else
		y->p->right = x;

	if(y!=z)
		z->key = y->key;

	if(y->color == Black)
		RB_Delete_Fixup(root,x);
}

void RB_Tree_Inoder(RB_Node *root)
{
	if(root!=T_NULL)
	{
		RB_Tree_Inoder(root->left);
		printf("%d  ,",root->key);
		RB_Tree_Inoder(root->right);
	}
}
void RB_Tree_Create(p_RB_Node *root)
{
	int a[] = {12,1,9,2,0,11,7,19,4,15,18,5,14,13,10,16,6,3,8,17};
	for(int i = 0;i<20;i++)
	{
		RB_Insert(root,a[i]);
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	T_NULL = new RB_Node;
	T_NULL->color = Black;
	T_NULL->left = NULL;
	T_NULL->right = NULL;
	T_NULL->p = NULL;
	T_NULL->key = 0;
	RB_Node *root = T_NULL;
	RB_Tree_Create(&root);
	RB_Tree_Inoder(root);
	cout<<endl;
	RB_Delete_Node(&root,12);
	RB_Tree_Inoder(root);
	cout<<endl;
	RB_Delete_Node(&root,1);
	RB_Tree_Inoder(root);
	cout<<endl;
	RB_Delete_Node(&root,9);
	RB_Tree_Inoder(root);
	cout<<endl;
	return 0;
}

   



cyxHehui
关注
专栏目录
自己实现的 rb-tree 准备用在我的网络库中
syndro的专栏
06-08 242
#ifndef RB_TREE_H_#define RB_TREE_H_typedef struct RB_TREE_NODE{ int color; unsigned long long key; void* data; struct RB_TREE_NODE* p; struct RB_TREE_NODE* left; struct RB_TREE_NODE* right;} RB_TRE
TreeMap红黑树解析
xizhuyuan1676的博客
11-05 720
TreeMap小白解析
红黑树(RB_Tree) 模版
12-07
这是本人写的一个红黑树的模版，只需要改一下接口就可以用了。基本操作查找，删除，修改都是O(logn).
红黑树（rb_tree） 源代码
脚踏实地，用心编写出客户满意的代码，为公司创造出应有的价值。
05-17 1077
红黑树 （rb_tree）源代码
红黑树原理解析以及Java实现
qq_32534441的博客
03-07 2484
转自：https://blog.csdn.net/u010853261/article/details/54312932 红黑树 本文的主要内容： 1、红黑树的基本概念以及最重要的5点规则。 2、红黑树的左旋转、右旋转、重新着色的原理与Java实现； 3、红黑树的增加结点、删除结点过程解析； 1.红黑树的基本概念与数据结构表示 首先红黑树来个定义： 红黑树定义：红黑树又称红-黑二叉树，...
红黑树的C语言简单实现与代码解析
最新发布
To learn, to engage.
12-23 960
红黑树是计算机科学中一种重要的自平衡二叉搜索树。它确保了在最坏情况下，基本的动态集合操作（如插入、删除和查找）具有对数时间复杂度。
红黑树解析
潘建南的博客
12-04 774
目录 概要                R-B Tree简介 红黑树的应用 红黑树的时间复杂度和相关证明 红黑树的基本操作(一) 左旋和右旋 红黑树的基本操作(二) 添加 红黑树的基本操作(三) 删除 红黑树和平衡二叉树区别 概要                     概述：R-B Tree，又称为“红黑树”。本文参考了《算法导论》中红黑树相关知识，加之自己的理解，然后以图...
深度解析红黑树
weixin_43274704的博客
08-01 2274
前言 红黑树是计算机科学中最难理解的数据结构之一，本文将带大家从认识红黑树的前世今生开始，探寻红黑树的结构和原理。 二叉查找树 二叉查找树的定义 二叉查找树是一种特殊的二叉树，其改善了二叉树结点查找的效率，二叉查找树具有以下性质： 对于任意一个节点n： 1、其左子树下的每个后代节点的值都小于节点n的值。 2、其右子树下的每个后代节点的值都大于节点n的值。 3、左右子树也均为二叉查找树。 所谓节点 n 的子树，可以将其看作是以节点 n 为根节点的树。子树的所有节点都是节点 n 的后代，而子树的根则是节点 n
红黑树维持平衡的方式解析
xiaosong_2016的博客
12-10 7392
在对红黑树进行添加或者删除操作时可能会破坏这些特点，所以红黑树采取了很多方式来维护这些特点，从而维持平衡。主要通过修改颜色（颜色反转）和旋转节点（左旋转、右旋转）来完成平衡。 左旋（RotateLeft） 逆时针旋转红黑树的两个结点，使得父结点被自己的右孩子取代，而自己成为自己的左孩子 上图所示过程如下： 1. 以X为基点逆时针旋转 2. X的父节点被x原来的右孩子Y取代 3. c保持不变 4. Y节点原来的左孩子c变成X的右孩子 动态过程如下 右旋（RotateRight） 顺.
C++实现红黑树
hdsHDS6的博客
06-28 1650
C++实现红黑树，插入和删除思路
红黑树原理简单解析
黄沙客栈
08-19 9962
一、红黑树为什么会出现呢？ 是因为二叉搜索树有可能会出现极端的情况，就是只有一侧有数据，那这样的话就会降级为链表。后来出现了平衡二叉树，但是由于强制平衡所导致付出的代价比较高昂，所以黑红树出现了。 二、简介 红黑树（Red Black Tree） 的实现是基于二叉查找树的，对于含有n个节点的二叉查找树的最坏的情况是这n个节点形成一条单链，此时二叉查找树的高度为n，时间复杂度为O(n)。为了维持O(lg n)的运行时间，就需要采取一些措施在不影响二叉查找树的性质下改变二叉查找树的结构，使之平衡。红黑树就是这样
平衡树与红黑树解析与比较
下面将详细介绍红黑树的原理与实现。 1. **什么是红黑树** 红黑树是一种特殊的二叉搜索树，具有以下性质： - 每个节点要么是红色，要么是黑色。 - 根节点是黑色的。 - 每个叶节点（NIL节点，空节点）是黑色的。 - ...
红黑树与TreeMap详细解析
李利科
02-21 510
一、为什么要创建红黑树这种数据结构 在上篇我们了解了AVL树，既然已经有了AVL这种平衡的二叉排序树，为什么还要有红黑树呢？ AVL树通过定义我们知道要求树中每一个结点的左右子树高度差的绝对值不超过1，其是一颗严格的平衡树，这样构建出来的平衡二叉排序树具有很好的查找性能，但是为了保持其每个结点平衡因子绝对值不超过1的特性在插入或者删除的时候需要的维护成本是很大的，插入或者删除需要大量的平衡度计算，比如上一篇在AVL的插入的时候就需要不断回溯其父节点调整平衡因子的值，数据量小没什么问题，但是实际应用中往往数.
动画演示！红黑树解析
静待花开
05-21 3635
红黑树动图解析 一、啥是红黑树？ 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。因此想要弄清楚红黑树，我们需要先解决几个问题： 二叉查找树是什么？ 为什么会出现红黑树？ 二、剖析二叉查找树 二叉查找树特性 二叉查找树（Binary Search Tree）是一颗二叉树，简称BST。就像我们说int都是整数一样，BST这一种二叉树需要满足如下三个特性： 某节点的左子树节点值仅包含小于该节点值 某节点的右子树节点值仅包含大于该
Hash结构详解
热门推荐
HeHui的专栏
02-20 1万+
1、什么是Hash       Hash，即”散列“，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换也是一种压缩映射，也就是散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，因此不可能从散列值来唯一确定输入值。简单地说就是将一种任意长度的消息压缩成某一固定长度的消息摘要的函数。        HASH主要用于信息安全领域中加密算法，它把一
B树的原理分析及实现
HeHui的专栏
11-26 9816
B树是为磁盘或其他直接存取的辅助设备而设计的一种平衡搜索树。许多数据库系统使用B树或B树的变种来存储信息。为何会采用这种树结构进行设计呢，《算法导论》18章讲得很到位，值得细细品味。    下面直接开始了解B树的实现细节吧！     一、B树的定义     它与二叉搜索树和红黑树一样，把卫星数据和关键字都存放在同一个结点中。     1、每个结点的属性：      （1）x.n: 每个结
字典树详解----串查找、排序、公共前缀之杀手锏
HeHui的专栏
02-21 6750
1、字典树       又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变形。典型应用是用于统计，排序和保存大量的字符串，所以经常被搜索引擎系统用于文本词频统计。它的优点是利用最大公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希表高。 2、性质  根节点不包含字符，除根节点以外的每
二叉查找树的原理与实现
HeHui的专栏
11-26 1040
二叉查找树，又名二叉搜索树，主要性质：左孩子 二叉查找树上的基本操作包括：search, minimum, maximum, predecessor, successor, insert, delete. 而这些操作基本所花费的时与这棵树的高度成正比。对于一棵完全树来说，这些操作的最坏运行时间为：O(lgn)，而对于n个结点连成一条线的树来说，则为O（n)。那如何才能保证所有的基本操作复杂度控
Java TreeMap与TreeSet实现红黑树解析
"Java中的`TreeMap`和`TreeSet`是两个集合类，它们都基于红黑树（Red-Black Tree）数据结构实现，提供高效且有序的操作。`TreeMap`是一个实现了`SortedMap`接口的类，用于存储键值对，而`TreeSet`则是实现了`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值