红黑树(RED-BLACK TREE)的插入和删除

最新推荐文章于 2023-04-19 14:35:26 发布
最新推荐文章于 2023-04-19 14:35:26 发布
阅读量880 收藏 1
点赞数
分类专栏： 查找 二叉树 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyapy/article/details/37726517
版权
二叉树 同时被 3 个专栏收录
26 篇文章 0 订阅
订阅专栏
算法
24 篇文章 0 订阅
订阅专栏
查找
15 篇文章 0 订阅
订阅专栏

        红黑树的插入和删除会需要用到旋转和颜色翻转。颜色翻转和旋转的主要目的是为了保证红黑树的5个性质，插入最直接来讲可能会导致根结点是红色(树为空)，红色结点的子结点为红色，这是需要进行红黑调整以及子树翻转。删除最直接的结果就是删除了黑色结点，那么导致沿着该结点的路径上的黑色结点数目发生变化，此时需要翻转颜色和旋转子树来平衡。

红黑树的左旋和右旋


图1  左旋和右旋示意图


左旋的伪代码：

LEFT-ROTATE(T,x)
y = x.right
x.right = y.left
if y.left != nil(T)
	y.left.p = x
y.p = x.p
if x.p == nil(T)
	T.root = y
elseif x == x.p.left
	x.p.left = y
else x.p.right = y
y.left = x
x.p = y


代码很好理解，不用赘述，右旋可以参照给出，很简单。

红黑树的插入情况可以修改二叉查找树的插入函数完成插入，同理删除情况也是如此。

插入可能导致的情形及应对的策略有下面几种：


图2  插入的情形(一侧)

上述3种情形还有三种对称的情形。

删除的情形以及其应对的策略如下：


图3  删除的情形(一侧)

代码：

#include <iostream>
#include <assert.h>
#include <stack>
#include <queue>
#include <iomanip>
using namespace std;

#define BLACK 0
#define RED 1
typedef struct RBTreeNode* RBTree;
typedef struct RBTreeNode{
	int data;
	int color;
	RBTree lchild,rchild,parent;
} RBTreeNode ; 


RBTree createNode(int key)
{
	RBTree ptr = new RBTreeNode;
	ptr->data = key;
	ptr->parent = NULL;
	ptr->color = RED;
	ptr->lchild = NULL;
	ptr->rchild = NULL; 
	return ptr;
}

RBTree& grandparent(RBTree ptr)
{
	/* parameter n is short for node */
	return ptr->parent->parent;
}


RBTree uncle(RBTree n)
{
	/* parameter n is short for node */
	if ( n->parent == grandparent(n)->lchild)
		return grandparent(n)->rchild;
	else
		return grandparent(n)->lchild; 
}
RBTree minimum(RBTree ptr)
{
	while (ptr->lchild != NULL) {
		ptr = ptr->lchild;
	}
	return ptr;
}
RBTree succ(RBTree ptr)
{
	if (ptr->rchild != NULL)
		return minimum(ptr->rchild);
	/*RBTree y = n->parent;
	while (y != NULL && n == y->rchild){
		n = y;
		y = y->parent;
	}
	return y;*/
}

RBTree leftRotate(RBTree *T,RBTree x)
{
	/*
	           |
			   x
			  / \
			 #   y
				/ \
				# #
	*/
	RBTree y = NULL;
	RBTree root =NULL;
	y = x->rchild;

	x->rchild  = y->lchild;
	if (y->lchild != NULL) {
		y->lchild->parent = x;
	}

	
	y->parent = x->parent;
	if (x->parent == NULL)
	{
		root = y;// x = y?
	}
	else if (x->parent->lchild == x) 
		x->parent->lchild = y;
	else
		x->parent->rchild = y;
	y->lchild = x;
	x->parent = y;
	if (root)
		*T = root;
	return y;
}

RBTree rightRotate(RBTree *T,RBTree y)
{
	
	/*
	              |
			      y
			     / \
			    x   #
			   / \
			   # #
	*/

	RBTree x =NULL;
	x = y->lchild;
	RBTree root = NULL;

	y->lchild = x->rchild;

	if (NULL != x->rchild) {
		x->rchild->parent = y;
		cout<<"Runned?"<<endl;
	}

	if (y->parent != NULL)
		x->parent = y->parent;
	else
		x->parent = NULL;

	if ((y)->parent == NULL)
		root = x;
	else { 
		if (y->parent->rchild = y)
			y->parent->rchild = x;
		else 
			y->parent->lchild = x;
	}

	x->rchild = y;
	y->parent = x;
	if (root)
		*T = root;
	return  x;
}

void RBInsertFixup(RBTree *T,RBTree z)
{
	RBTree y;
	RBTree p;
	while ((p = z->parent) != NULL && p->color == RED)
	{
		if (p == grandparent(z)->lchild){
			/*  parent of z is the lef child of grand parent of z */
			y = uncle(z);
			if (y != NULL && y->color == RED){
				/* case 1 : color flip*/ 
				z->parent->color = BLACK;
				grandparent(z)->color = RED;
				y->color = BLACK;
				z = grandparent(z);
			} 
			else {
				if (z == z->parent->rchild) {
					/* case 2 */ 
					z = z->parent;
					leftRotate(T,z);
				}
				//* case 3*/ / 
				z->parent->color = BLACK;
				grandparent(z)->color = RED;
				rightRotate(T,z->parent->parent);
			}			
		}
		else {
			/* z->p = z->p->p->rchild */
			y = uncle(z);
			if (y != NULL && y->color == RED){
				/*case 4 */
				z->parent->color = BLACK;
				grandparent(z)->color = RED;
				y->color = BLACK;
				z = grandparent(z);
			} 
			else {
				if (z == z->parent->lchild) {
					/*case 5*/
					z = z->parent;
					rightRotate(T,z);
				}
				/*case 6*/
				z->parent->color = BLACK;
				grandparent(z)->color = RED;
				leftRotate(T,z->parent->parent);
			}
		}
	}
	(*T)->color = BLACK; 
} 

void RBDeleteFixup(RBTree *T,RBTree xp,RBTree x)
{
	/* xp is parent of x */
	RBTree w;
	while( x != *T && (x == NULL || x->color == BLACK))
	{
		if (x == xp->lchild){
			/* w is sibling of x */
			w = xp->rchild;
			if (w->color == RED){
				//case 1
				w->color = BLACK;
				x->parent->color = RED;
				leftRotate(T,x->parent);
				w = xp->rchild;
			}
			if ((w->lchild == NULL || w->lchild->color == BLACK) &&
				(w->rchild == NULL || w->rchild->color == BLACK)){
					//case 2
					w->color = RED;
					x = xp;
					xp = xp->parent;
			}
			else {
				if (w->rchild == NULL || w->rchild->color == BLACK){
					// case 3
					w->lchild->color = BLACK;
					w->color = RED;
					rightRotate(T,w);
					w = xp->rchild;
				}
				// case 4
				w->color = xp->color;
				xp->color = BLACK;
				w->rchild->color = BLACK;
				leftRotate(T,xp);
				x = *T;
			}
		}
		else {
			/* x == xp->rchild and  w is sibling of x*/
			w = xp->lchild;
			if (w->color == RED){
				//case 1
				w->color = BLACK;
				xp->color = RED;
				rightRotate(T,xp);
				w = xp->lchild;
			}
			if ((w->lchild == NULL || w->lchild->color == BLACK) &&
				(w->rchild == NULL || w->rchild->color == BLACK)){
					//case 2
					w->color = RED;
					x = xp;
					xp = xp->parent;
			}
			else {
				if (w->lchild == NULL || w->lchild->color == BLACK){
					// case 3
					w->rchild->color = BLACK;
					w->color = RED;
					leftRotate(T,w);
					w = xp->lchild;
				}
				// case 4
				w->color = xp->color;
				xp->color = BLACK;
				w->lchild->color = BLACK;
				rightRotate(T,xp);
				x = *T;
			}			
		}
	}
	if (x != NULL)
		x->color = BLACK;
}

void RBInsert(RBTree *T,int key)
{
	RBTree z = createNode(key);
	assert(z != NULL);

	RBTree y = NULL;
	RBTree x = *T;

	while (x != NULL) {
		y = x;
		if ( z->data < x->data)
			x = x->lchild;
		else if (z->data == x->data) {
			cout<<"Key = "<<z->data<<" is already in the RB-Tree."<<endl;
			delete z;
			return;
		}
		else {
			x = x->rchild;
		}			
	}

	z->parent = y;

	if (y == NULL) {
		*T = z;
	}
	else if (z->data < y->data) {
		y->lchild = z;
	}
	else {
		y->rchild = z;
	}
	z->lchild = NULL;
	z->rchild = NULL;
	z->color = RED;
	RBInsertFixup(T,z); 
} 


void RBDelete(RBTree *T,int key)
{
	RBTree z = *T;
	RBTree x,y;
	x = y = NULL;
	bool found = false;
	while ( z != NULL) {
		if (key < z->data)
			z = z->lchild;
		else if (key > z->data)
			z = z->rchild;
		else {
			found = true;
			break; 
		} 
	}

	if (!found) {
		cout<<"Key = "<<key<<" is not in the tree."<<endl;
		return;
	}
	/* copy data of y into z and delete y*/
	if (z->lchild == NULL || z->rchild == NULL)
		y = z;
	else
		y = succ(z);
	/* x will be subtree of y */
	if (y->lchild != NULL) {
		x = y->lchild;
	}
	else 
		/* is it ok? */
		x = y->rchild;

	/* x link to parent of y */	
	if (x != NULL)
		x->parent = y->parent;

	if(y->parent == NULL) {
		/* if y is the root of Tree */
		*T = x;
	}
	else if (y == y->parent->lchild) 
		y->parent->lchild = x;
	else 
		y->parent->rchild = x;
	if (y != z) {
		/* copy data of y into z */
		z->data = y->data;
	}
	if (y->color == BLACK)
		RBDeleteFixup(T,y->parent,x);
	delete y;
}

inline int max(int a,int b)
{
	return a>b?a:b;
}
int Height(RBTree T)
{
	if (T == NULL)
		return 0;
	else
		return 1 + max(Height(T->lchild), Height(T->rchild));
}
void MakeMat(RBTree T,int root_x,int root_y,int step,int **m)
{
	int lChildPos,rChildPos;
	lChildPos = root_x - step;
	rChildPos = root_x + step;
	if (T == NULL) 
		return;
	else
	{
		m[root_y][root_x] = 1;
		MakeMat(T->lchild,lChildPos,root_y+1,step>>1,m);
		MakeMat(T->rchild,rChildPos,root_y+1,step>>1,m);
	}
}

void RBTreeDisplay(RBTree T)
{
	if(T == NULL)
		return;
	/* init placehold flags m[h][len] */
	int h = Height(T);
	int len = (1<<h) - 1;
	int row = h; 
	int **m = new int*[row];
	for(int i= 0;i<row;i++){
		m[i] = new int[len];
		memset(m[i],0,len*sizeof(int));	
	}
	/* get level order traversal sequence */
	vector<RBTree> v;
	queue<RBTree> q;
	queue<RBTree> qt;
	q.push(T);
	RBTree pt;
	while(!q.empty())
	{
		pt = q.front();
		if (pt->lchild != NULL)
			q.push(pt->lchild);
		if(pt->rchild != NULL)
			q.push(pt->rchild);
		v.push_back(pt);		
		q.pop();
	}
	/* generate output matrix  plus '/' and '\\' m[2*h-1][len] */
	MakeMat(T,len>>1,0,len+1>>2,m);
	/* generate output */
	int cnt = 0;
	int width = 2;
	for(int i = 0; i < row; i++)
	{
		for(int j = 0; j < len; j++)
		{
			if(m[i][j])
			{
				cout<<((v[cnt])->color?'R':'B')<<":"<<(v[cnt])->data;
				cnt++;
			}
			else
				cout<<setw(width)<<' ';		
		}
		cout<<endl;
	}

}
int main()
{
	RBTree T = NULL;
	int i; 
	int a[] = {12,1,9,0,2,11,7};
	for (i = 0; i < 7; i++) {
		cout<<"Inserting key = "<<a[i]<<endl;
		RBInsert(&T,a[i]);
		RBTreeDisplay(T);
		cout<<endl;
		cout<<"----------------------------------------------------------"<<endl;;
	}
	cout<<"Inserting key = "<<2<<endl;
	RBInsert(&T,2);
	RBTreeDisplay(T);
	cout<<endl;
	cout<<"----------------------------------------------------------"<<endl;
	
	cout<<"Deleting key = "<<2<<endl;
	RBDelete(&T,2);
	RBTreeDisplay(T);
	cout<<endl;
	cout<<"----------------------------------------------------------"<<endl;
	
	cout<<"Deleting key = "<<7<<endl;
	RBDelete(&T,7);
	RBTreeDisplay(T);
	cout<<endl;
	cout<<"----------------------------------------------------------"<<endl;
	for (i = 0;i < 7;i++)
	{
		cout<<"Deleting key = "<<a[i]<<endl;
		RBDelete(&T,a[i]);
		RBTreeDisplay(T);
		cout<<endl;
		cout<<"----------------------------------------------------------"<<endl;
	}
}


测试结果： 

Inserting key = 12
B:12

----------------------------------------------------------
Inserting key = 1
  B:12  
R:1    

----------------------------------------------------------
Inserting key = 9
  B:9  
R:1  R:12

----------------------------------------------------------
Inserting key = 0
      B:9      
  B:1      B:12  
R:0            

----------------------------------------------------------
Inserting key = 2
      B:9      
  B:1      B:12  
R:0  R:2        

----------------------------------------------------------
Inserting key = 11
      B:9      
  B:1      B:12  
R:0  R:2  R:11    

----------------------------------------------------------
Inserting key = 7
              B:9              
      R:1              B:12      
  B:0      B:2      R:11          
            R:7                

----------------------------------------------------------
Inserting key = 2
Key = 2 is already in the RB-Tree.
              B:9              
      R:1              B:12      
  B:0      B:2      R:11          
            R:7                

----------------------------------------------------------
Deleting key = 2
      B:9      
  R:1      B:12  
B:0  B:7  R:11    

----------------------------------------------------------
Deleting key = 7
      B:9      
  B:1      B:12  
R:0      R:11    

----------------------------------------------------------
Deleting key = 12
      B:9      
  B:1      B:11  
R:0            

----------------------------------------------------------
Deleting key = 1
  B:9  
B:0  B:11

----------------------------------------------------------
Deleting key = 9
  B:11  
R:0    

----------------------------------------------------------
Deleting key = 0
B:11

----------------------------------------------------------
Deleting key = 2
Key = 2 is not in the tree.
B:11

----------------------------------------------------------
Deleting key = 11

----------------------------------------------------------
Deleting key = 7
Key = 7 is not in the tree.

----------------------------------------------------------
REF：

1，算法导论 红黑树章节

2，http://chiyx.iteye.com/blog/1663013

Scandinavians
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javascript图解红黑树
雨的印记的博客
02-28 450
图解红黑树 目录图解红黑树一、红黑树的五条规则二、红黑树的三种变换2.1.变色2.2.左旋转2.3.右旋转三、红黑树的插入操作3.1.情况13.2.情况23.3.情况33.4.情况43.5.情况53.6.案例插入10插入9插入8插入7插入6插入5插入4插入3插入2**插入1**四、红黑树的删除操作 一、红黑树的五条规则 红黑树除了符合二叉搜索树的基本规则外，还添加了以下特性： 规则1：节点是红色或黑色的； 规则2：根节点是黑色的； 规则3：每个叶子节点都是黑色的空节点（NIL节点）； 规则4：每个红色节点
红黑树详解
cnh294141800的专栏
05-09 1521
红黑树  一.红黑树定义 红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。 红黑树是特殊的二叉查找树，意味着它满足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。 除了具备该特性之外，红黑树还包括许多额外的信息。 红黑树的每个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。 红黑树的特性
红黑树(Red Black Tree)超详细解析
qq_65786321的博客
11-09 943
​ 红黑树，是一种二叉搜索树的特化，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。​ 红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。
基于QT Creator的红黑树
%%%
11-15 665
采用QT的按钮实现插入删除等控制，采用QT的文本框输出红黑树。 main.cpp #include "mainwindow.h" #include &lt;QApplication&gt; #include "rbtree.h" int main(int argc, char *argv[]) { QApplication a(argc, argv); MainWindow...
深入剖析 Qt QMap：原理、应用与技巧
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-19 6741
qmap
红黑树的插入与删除(一)
蚂蚁的博客
08-15 816
红黑树作为同样提供O(log n)查询的树结构，通常用于关联数组的使用中，相对于AVL树，在插入和删除操作中能够以更少的调节操作来位置平衡，AVL树的平衡唯一标准就是其高度，
C#，红黑树（Red-Black Tree）的构造，插入、删除及修复、查找的算法与源代码
最新发布
04-09
C#，红黑树（Red-Black Tree）的构造，插入、删除及修复、查找的算法与源代码 1 红黑树（Red-Black Tree） 如果二叉搜索树满足以下红黑属性，则它是红黑树： 每个节点不是红色就是黑色。 根是黑色的。 每片叶子（无...
red-black-tree:Ada 2012实施一棵红黑树
05-13
红黑树 这是Ada 2012对（一种自平衡二进制搜索树）的实现。 该树使用标准的Ada.Iterator_Interfaces进行迭代。 with Ada.Integer_Text_IO ; use Ada.Integer_Text_IO; with Ada.Text_IO ; use Ada.Text_IO; with ...
RED-BLACK-tree-and-2-3-4tree.rar_234树到红黑树_红黑树
09-23
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由IBM的研究员鲁道夫·贝尔在1972年提出。它的设计目标是在插入、删除和查找操作上保持近似最坏情况下的O(log n)时间复杂度，同时通过特定的颜色规则保证树的平衡...
js-red-black-tree：JavaScript的红黑树库
02-12
:Christmas_tree: let tree = RedBlackTree . from ( increasing , range ( 100000 ) ) ; JavaScript的红黑树库。 请参阅。 父母是 。
红黑树的源码与测试函数
05-15
rbtree源码与测试函数
关于红黑树（Red-Black Tree）英文论文
07-09
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中用于实现关联数组。这种数据结构最初由Rudolf Bayer在1972年发明，当时称为“对称二叉B树”，但在1978年由Leonidas J. Guibas和Robert Sedgewick...
红黑树(Red–black tree)
小码农想做大架构的博客
06-17 804
一、红黑树的概念: 在计算机科学中，红黑树是一种自平衡二叉搜索树。每个节点存储一个表示“颜色”（“红”或“黑”）的额外位，用于确保树在插入和删除期间保持平衡。 当树被修改时，新树被重新排列和“重新绘制”以恢复着色属性(整个树的红黑结点会重新进行绘制，以适应红黑树的颜色排列规则)，这些属性限制了树在最坏情况下的不平衡程度。属性的设计使得这种重新排列和重新排序可以有效地执行。 重新平衡不是完美的(不能像平衡二叉树一样绝对平衡，只能做到相对平衡)，但保证了搜索的时间，其中是树的节点数。插入和删除操作以及树的重新
Qt入门教程【STL篇】QMap红黑树键值对
小鱼酱的博客
03-11 1868
Qt中QMap红黑树键值对象使用方法
红黑树(一)之 原理和算法详细介绍
kk的博客
08-13 755
概要 目录1 红黑树的介绍2 红黑树的应用3 红黑树的时间复杂度和相关证明4 红黑树的基本操作(一) 左旋和右旋5 红黑树的基本操作(二) 添加6 红黑树的基本操作(三) 删除 作者：Sky Wang 于 2013-08-08 概述：R-B Tree，又称为“红黑树”。本文参考了《算法导论》中...
那些年，面试被虐过的红黑树
weixin_34211761的博客
03-27 493
2019独角兽企业重金招聘Python工程师标准>>> ...
红黑树（Red-Black tree）
学习日常分享
02-19 1744
红黑树定义 Red-Black tree, 简称RB-Tree 它是在1972年由鲁道夫·贝尔发明的，他称之为“对称二叉B树”，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的 特点：利用对树中的结点 “红黑着色”的要求，降低了平衡性的条件，达到局部平衡，有着良好的最坏情况运行时间，它可以在O(log n)时间内做查找，插入和删除，这里的n是树中元素的数目。 红黑树的应用 典型的用途是：关联数组 C++ STL中的关联式容器：集合set、多
利用Matlab实现二叉树的树形显示
热门推荐
flyapy
07-03 1万+
接文章《求二叉树的高度以及二叉树的树形显示》，当求出erweiju
2-3-4树与红黑树的对应关系
flyapy
07-09 3841
2-3-4树和红黑树之间
f. red-black number
03-16
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，它的每个节点都带有颜色属性，可以是红色或黑色。通过对任何一条从根到叶子节点的路径上各个节点的颜色进行约束，红黑树保证了没有一条路径会比其他路径长出两倍...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值