红黑树

最新推荐文章于 2022-03-26 18:15:01 发布
置顶 最新推荐文章于 2022-03-26 18:15:01 发布
阅读量178 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaohui987987/article/details/81510971
版权

看红黑树之前先看AVL树有很多相似的地方，我也写了一篇AVL树的总结，我就没重复总结了。

 

我们先看红黑树特性

1.根节点是黑色

2.每个节点只能是黑色或者红色

3.如果一个节点是红色，它得子节点必须是黑色的。

4.每个叶子节点(NIL)是黑色的，这里可以是所有叶子节点连着最后一个（黑色的）哨兵节点（为NULL）。

5.从任意一个节点到其叶子节点的所有路径中，包含相同数目的黑色的节点。（不能从父节点回退）

看一下红黑树的长相

红黑树的高度问题

由于它的特性所影响，从根节点出发，整个红黑树的最长路径(树的高度)不会超过最短路径的2倍。看张图就知道了

看完图也可以看一下推导思路

一棵含n个结点的红黑树最大的高度不超过2log(n+1)。我简单说下思路

（1）我们先假设该定理成立  推导出     h <= 2log(n+1)    再推导得       n >  2 ^(h/2) -1             (^ 是平方的意思)

（2）上面推导出 一棵高度为h 的红黑树它至少 有 n 个节点

（3) 我们设任意节点到该叶子节点的黑结点个数为B(hx)。特性3  红色节点子节点必须是黑色的。得出一棵树的高度的  B(hx) >=h/2。原因有以下几点。

结点只能为黑或者红。红节点子节点为黑。

意味着一条路径有一个红就会有一个黑节点。

从任意一个节点到其叶子节点得所有路径中，包含相同数目的黑色节点。意味着黑色节点数目唯一性。

而树的高度。便是最长路径的节点的个数，推出 该路径的 "黑节点个数" >= h/2      也就是       B(hx) >= h/2

(4) 根据两个公式   n >=  2^(h/2)-1    和  B(hx) >=h/2     推出    n  >=  2^(B(hx)-1

(5)数学归纳法过程

红黑树高度 = 0      带入公式 n>= 2^B(hx)-1            0>= 0成立

红黑树高度为 h-1     黑节点个数 为 B(hx) （从红节点开始） 或者B(hx)-1  （从黑节点开始） 

我们要证明高度为h  至少含多少个内节点  。这时候就要取高度h-1  黑节点小的时候。

n > = (2^(B(hx)-1) -1) + (2^(B(hx)-1 )-1) +1   (这种情况是从黑节点开始的，所以+1)

n>= (2^(B(hx)-1)

 

再看一下红黑树的结构体

Color Type 是枚举类型   说明它的性质非红即黑。（不要和我说没颜色）

Nil 是一个哨兵位

 

typedef int KeyType;
typedef enum {RED = 0, BLACK = 1} ColorType;
typedef struct rb_node
{
	rb_node *leftchild;
	rb_node *parent;
	rb_node *rightchild;
	ColorType color; // 
	KeyType key;
}rb_node;

typedef struct        //头节点head
{
	rb_node *head;
	rb_node *Nil;
	int cursize;
}RBTree;

 

平衡二叉树和红黑树的区别

 (1) 平衡二叉树和红黑树都是通过特性来控制树的高度

平衡二叉树控制平衡相对比较严格，左子树高度和右子树的高度差不能超过1。

而红黑树是通过特性和颜色来相对控制其平衡

（2）平衡二叉树插入新节点时候，效率会低很多，红黑树则效率快一些

 

我们分析一下几种插入情况插入时候，（新插入节点是红色，但是他的颜色在双旋之后是可以变黑的。这个颜色不能随着旋转之类的变掉颜色）

新节点一定是红色，插入进去，父节点是黑色，皆大欢喜，我直接插入，不要调整

但是如果是父节点为红色

我们画个图

第一种情况

叔叔爸爸都为红，就把爷爷染红，叔叔爸爸染黑

 

第二种情况

叔叔为爷爷的左孩子且为黑色节点，父亲节点为红色，这时候就需要左旋或者双旋

看图

第三种情况

叔叔为右节点且为黑色，父亲为红色，可能要右旋或者双旋。

 

这个是核心代码你看下

//pa为新节点的父节点
void Insert_Item(RBTree *ptree,rb_node *pa,KeyType kx)
{
	rb_node *s = Buynode(pa,RED);   //创新节点
	s->key = kx;
	s->leftchild = ptree->Nil;
	s->rightchild = ptree->Nil;
	if(kx < pa->key)    //当kx 小于pa->key
	{
		pa->leftchild = s;   //s为pa的左孩子
		if(kx < ptree->head->leftchild->key)  //头连着左孩子连着整个树最小关键词  
		{
			ptree->head->leftchild = s;
		}
	}

	else
	{
		pa->rightchild = s;
		if(kx > ptree->head->rightchild->key)      //头右孩子连着最大关键词
		{
			ptree->head->rightchild = s;
		}
	}
	//
	rb_node *_Y = NULL;          // _Y 为叔叔节点
	rb_node *_X = s;            //_X在循环里为孙子节点
	for(;_X != ptree->head->parent && _X->parent->color == RED ;)
	{
		if(_X->parent == _X->parent->parent->rightchild)
		{
			_Y = _X->parent->parent->leftchild;
			if(_Y->color == RED)  //变颜色即可
			{
				_Y->color = BLACK;
				_X->parent->color = BLACK;
				_X->parent->parent->color = RED;
				_X = _X->parent->parent;
			}
			else
			{
				if(_X->parent->leftchild == _X)   //双旋情况
				{
					_X = _X->parent; 
					RotateRight(ptree,_X);
				}        

				_X->parent->color = BLACK;     //没执行上面的if为单旋
				_X->parent->parent->color = RED;
				RotateLeft(ptree,_X->parent->parent);
			}
		}
		else
		{
			_Y = _X->parent->parent->rightchild;
			if(_Y->color = RED)
			{
				_Y->color = BLACK;
				_X->parent->color = BLACK;
				_X->parent->parent->color = RED;
				_X = _X->parent->parent;
			}
			else
			{
				if(_X->parent->rightchild == _X)
				{
					_X = _X->parent;
					RotateLeft(ptree,_X);
				}
				_X->parent->color = BLACK;
				_X->parent->parent->color = RED;
				RotateRight(ptree,_X->parent->parent);
			}
		}
	}
	ptree->head->parent->color = BLACK;    //就是上面说的根就算变红了最后循环出来涂黑就好

}

 

我们看一下红黑树的左旋

这个左旋和 平衡二叉树里提及的左旋是一个道理。我在AVL树博客里总结了，我这里简单提一下

节点颜色的调整都是在Insert_Item(BTree *ptree,rb_node *pa,KeyType kx)

这里左旋函数只关心节点的调整，不用关心节点颜色。

判断时候不要拿NULL 来判断，拿哨兵节点来判断

 

void RotateLeft(RBTree *ptree,rb_node *ptr)
{
	rb_node * newroot = ptr->rightchild;
	newroot->parent = ptr->parent; //1
	ptr->rightchild = newroot->leftchild;
	if(newroot->leftchild != ptree->Nil)
	{
		newroot->leftchild->parent = ptr;//2
	}

	newroot->leftchild = ptr;
	if(ptree->head->parent == ptr)
	{
		ptree->head->parent = newroot;
	}
	else
	{
		if(ptr->parent->rightchild == ptr)
		{
			ptr->parent->rightchild = newroot;
		}
		else
		{
			ptr->parent->leftchild = newroot;
		}
	}
	ptr->parent = newroot;
}

 

看下总代码

#include<iostream>
#include<stack>
#include<queue>
#include <assert.h>
using namespace std;
typedef int KeyType;
typedef enum {RED = 0, BLACK = 1} ColorType;

typedef struct rb_node
{
	rb_node *leftchild;
	rb_node *parent;
	rb_node *rightchild;
	ColorType color; // 
	KeyType key;
}rb_node;

typedef struct 
{
	rb_node *head;
	rb_node *Nil;
	int cursize;
}RBTree;

rb_node * Buynode(rb_node *pa = NULL,ColorType color = RED)
{
	rb_node *s = (rb_node*)malloc(sizeof(rb_node));
	if(NULL == s) exit(1);
	memset(s,0,sizeof(rb_node));
	s->parent = pa;
	s->color = color;
	s->leftchild = NULL;
	s->rightchild = NULL;
	return s;
}

void Freenode(rb_node *p)
{
	free(p);
}

void Init_BTree(RBTree *ptree)
{
	assert(ptree != NULL);
	ptree->Nil = Buynode(NULL,BLACK);
	ptree->head = Buynode(ptree->Nil,RED);
	ptree->head->leftchild = ptree->Nil;
	ptree->head->rightchild = ptree->Nil;
	ptree->cursize = 0;
}

void RotateLeft(RBTree *ptree,rb_node *ptr)
{
	rb_node * newroot = ptr->rightchild;
	newroot->parent = ptr->parent; //1
	ptr->rightchild = newroot->leftchild;
	if(newroot->leftchild != ptree->Nil)
	{
		newroot->leftchild->parent = ptr;//2
	}

	newroot->leftchild = ptr;
	if(ptree->head->parent == ptr)
	{
		ptree->head->parent = newroot;
	}
	else
	{
		if(ptr->parent->rightchild == ptr)
		{
			ptr->parent->rightchild = newroot;
		}
		else
		{
			ptr->parent->leftchild = newroot;
		}
	}
	ptr->parent = newroot;
}

void RotateRight(RBTree *ptree,rb_node *ptr)
{
	rb_node *newroot = ptr->leftchild;
	ptr->leftchild = newroot->rightchild;
	newroot->rightchild = ptr;
	if(ptree->head->parent == ptr)
	{
		ptree->head->parent = newroot;
	}
	else
	{
		if(ptr->parent->leftchild == ptr)
		{
			ptr->parent->leftchild = newroot;
		}
		else
		{
			ptr->parent->rightchild = newroot;
		}
	}
}

void Insert_Item(RBTree *ptree,rb_node *pa,KeyType kx)
{
	rb_node *s = Buynode(pa,RED);
	s->key = kx;
	s->leftchild = ptree->Nil;
	s->rightchild = ptree->Nil;
	if(kx < pa->key)
	{
		pa->leftchild = s;
		if(kx < ptree->head->leftchild->key)
		{
			ptree->head->leftchild = s;
		}
	}
	else
	{
		pa->rightchild = s;
		if(kx > ptree->head->rightchild->key)
		{
			ptree->head->rightchild = s;
		}
	}
	//
	rb_node *_Y = NULL;
	rb_node *_X = s;
	for(;_X != ptree->head->parent && _X->parent->color == RED ;)
	{
		if(_X->parent == _X->parent->parent->rightchild)
		{
			_Y = _X->parent->parent->leftchild;
			if(_Y->color == RED)
			{
				_Y->color = BLACK;
				_X->parent->color = BLACK;
				_X->parent->parent->color = RED;
				_X = _X->parent->parent;
			}
			else
			{
				if(_X->parent->leftchild == _X)
				{
					_X = _X->parent;
					RotateRight(ptree,_X);
				}
				_X->parent->color = BLACK;
				_X->parent->parent->color = RED;
				RotateLeft(ptree,_X->parent->parent);
			}
		}
		else
		{
			_Y = _X->parent->parent->rightchild;
			if(_Y->color = RED)
			{
				_Y->color = BLACK;
				_X->parent->color = BLACK;
				_X->parent->parent->color = RED;
				_X = _X->parent->parent;
			}
			else
			{
				if(_X->parent->rightchild == _X)
				{
					_X = _X->parent;
					RotateLeft(ptree,_X);
				}
				_X->parent->color = BLACK;
				_X->parent->parent->color = RED;
				RotateRight(ptree,_X->parent->parent);
			}
		}
	}
	ptree->head->parent->color = BLACK;

}

bool Insert(RBTree *ptree,KeyType kx)
{
	if(ptree == NULL) return false;       
	if(ptree->head->parent == ptree->Nil)            //此时是个空树
	{
		rb_node *s = Buynode(ptree->head,BLACK);
		s->key = kx;
		s->leftchild = ptree->Nil;
		s->rightchild = ptree->Nil;
		ptree->head->parent = s;
		ptree->head->leftchild = s;
		ptree->head->rightchild = s;
		ptree->cursize = 1;
		return true;
	}
	/
	rb_node *pa = ptree->head;                   
	rb_node *p = ptree->head->parent; // root;
	while(p != ptree->Nil && p->key != kx)
	{
		pa = p;
		p = kx < p->key ? p->leftchild:p->rightchild;
	}
	if(p != ptree->Nil && p->key == kx) return false;
	Insert_Item(ptree,pa,kx);
	ptree->cursize+=1;
	return true;
}

 

洗菜剑心
关注
专栏目录
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种自平衡二叉查找树，它的主要特点是在保持二叉查找树特性的同时，通过特定的颜色规则来确保树的平衡，以达到快速查找、插入和删除的目的。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。在插入新...
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未直接提供红黑树的类，但我们可以自定义实现，如提供的`Red...
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 171万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 22万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
C++红黑树
~
03-26 6750
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树详解
lucyLee的博客
09-12 10万+
1. 概述 1.1 红黑树的引入 有了二叉搜索树，为什么还需要平衡二叉树？ 在学习二叉搜索树、平衡二叉树时，我们不止一次提到，二叉搜索树容易退化成一条链 这时，查找的时间复杂度从O(log2N)O(log_2N)O(log2​N)也将退化成O(N)O(N)O(N) 引入对左右子树高度差有限制的平衡二叉树，保证查找操作的最坏时间复杂度也为O(log2N)O(log_2N)O(log2​N) 有了平衡二叉树，为什么还需要红黑树？ AVL的左右子树高度差不能超过1，每次进行插入/删除操作时，几乎都需要通过旋
红黑树与区间树算法实现
04-08
红黑树和区间树是两种在计算机科学中广泛使用的数据结构，主要应用于高效的数据管理和查询。在本实验中，我们探讨了如何用C++来实现这两种数据结构，并提供了相关的可视化功能。 红黑树是一种自平衡二叉查找树，由...
红黑树：红黑树的Matlab实现-matlab开发
05-30
红黑树是一种自平衡二叉查找树，由Rudolf Bayer于1972年提出。它的设计目标是在保持二叉查找树基本性质的同时，通过引入颜色（红色或黑色）来确保任何节点到其每个叶子节点的所有路径都具有相同的黑色节点数，从而...
控制台打印红黑树.rar
05-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家鲁道夫·贝尔在1978年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而优化了查找、插入和删除操作的时间复杂度。红黑树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值