红黑树代码

最新推荐文章于 2024-10-28 20:17:08 发布
最新推荐文章于 2024-10-28 20:17:08 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： 算法 数据结构 文章标签： class delete insert search null xp
 

总结：这章介绍了红黑树的性质、旋转，并详细介绍了红黑树的插入和删除。

 

1.    红黑树的性质

1）  每个节点或是红的，或是黑的

2）  根节点是黑的

3）  每个叶节点（NIL）是黑的

4）  如果一个节点是红的，则它的两个儿子都是黑的

5）  对每个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑节点。

 

黑高度：从某个节点x出发到大一个叶节点的任意一条路径上，黑色节点的个数称为该节点的黑高度，用bh(x)表示。

 

红黑树是一种好的二叉查找树，对一棵有n个内节点的红黑树的高度至多为2lg(n+1)，STL中的set和map就是用红黑树实现的。

红黑树的动态集合操作SEARCH, MINIMUM, MAXIMUM, SUCCESSOR, PREDECESSOR与二叉查找树的对应操作的实现一样，且它们的时间复杂度都是O(lgn)

 

2.    旋转

复杂度O(1)

 

 

左旋：

伪代码

LEFT-ROTATE(T,x)

y <- right[x]

if left[y]!=NIL[T]

      then p[left[y]] <- x

right[x] <- left[y]

p[y] <- p[x]

if p[x]=NIL[T]

      then root[T] <- y

      else if x=left[p[x]]

                 then left[p[x]] <- y

                 else right[p[x]] <- y

p[x] <- y

left[y] <- x

 

右旋：

伪代码

RIGHT-ROTATE(T,y)

x <- left[y]

left[y] <- right[x]

if right[x]!=NIL[T]

      p[right[x]] <- y

p[x] <- p[y]

if p[y]=NIL[T]

      then root[T] <- x

      else if y=left[p[y]]

                 then left[p[y]] <- x

                 else right[p[y]] <- x

p[y] <- x

right[x] <- y

 

3.    插入

时间复杂度O(lgn)

 

插入操作类似二叉查找树的插入，然后将插入的节点的颜色设为RED，由于插入操作可能破坏红黑树的性质2（当插入的是根节点时）和性质4（当父节点为红色节点时），因此需要额外的RB-INSERT-FIXUP操作来进行红黑树性质的保持。

 

伪代码

RB-INSERT(T,z)

y <- NIL[T]

x <- root[T]

while x!=NIL[T]

      do y <- x

           if key[z] < key[x]

                 then x <- left[x]

                 else x <- right[x]

p[z] <- y

if y=NIL[T]

      then root[T] <- z

      else if key[z] < left[y]

                 then left[y] <- z

                 else right[y] <- z

left[z] <- NIL[T]

right[z] <- NIL[T]

color[z] <- RED

RB-INSERT-FIXUP(T,z)

 

分情况讨论RB-INSERT-FIXUP：

首先，如果红黑树的性质2遭到破坏，那么只要简单的将根节点改为黑色即可。

其次，如果红黑树的性质4遭到破坏，即插入节点的父节点也为红节点，那么该节点一定有祖父节点，否则就不满足性质2，且该节点的祖父节点一定为黑色，否则不满足性质4。

设插入节点是z

这里有两组可能性，一是p[z]是p[p[z]]的左儿子，二是p[z]是p[p[z]]的右儿子。每组情况中又有三种子情况。仅讨论第一组情况。

在第一组条件下，又有三种情况：

Case1: z的叔父节点（即p[p[z]]的右儿子）的颜色为红色，则将z的父节点及z的叔父节点的颜色改为黑色，将z的祖父节点的颜色改为红色，然后将z上升至祖父节点，继续循环，保持红黑树的性质。

 

Case2: z的叔父节点的颜色为黑色，且z是p[z]的右儿子。对于这种情况，我们将Case2变为Case3，然后再处理Case3即可，即将z变为p[z]的左儿子。这可以通过将以p[z]为根的子树进行左旋，然后z指向原来的p[z]，这样情况变为Case3。

 

Case3: 将p[p[z]]设为红色，将p[z]设为黑色，然后对以p[p[z]]为根的子树进行右旋。

 

 

伪代码

RB-INSERT-FIXUP(T,z)

while color[p[z]]=RED

      do if p[z]=left[p[p[z]]]

                 then y <- right[p[p[z]]]

                      if color[y]=RED

                            then color[y] <- BLACK

                                    color[p[z]] <- BLACK

                                    color[p[p[z]]] <- RED

                                    z <- p[p[z]]

                      else

then if z=right[p[z]]

                                       then z <- p[z]

LEFT-ROTATE(T,z)

                                   color[p[z]] <- BLACK

                                   color[p[p[z]]] <- RED

                                   RIGHT-ROTATE(T,p[p[z]])

         else (same as then clause with “right” and “left” exchanged)

color[root[T]] <- BLACK

 

4.    删除

时间复杂度O(lgn)

 

红黑树的删除操作类似二叉查找树的删除操作，但是当删除的节点是黑色节点时，性质2（删除的是根节点，且一个红色孩子成为了新的根节点）、性质4（删除节点的父节点和孩子节点都为红色）、性质5（显然删除一个黑节点后，性质5无法满足）可能遭到破坏。因此，需要额外的RB-DELETE-FIXUP操作来进行红黑树性质的保持。

 

伪代码

RB-DELETE(T,z)

if left[z]=NIL[T] or right[z]=NIL[T]

      then y <- z

      else y <- TREE-SUCCESSOR(z)

if left[y]!=NIL[T]

      then x <- left[y]

      else x <- right[y]

p[x] <- p[y]

if p[x]=NIL[T]

      then root[T] <- x

else if y=left[p[y]]

                 then left[p[y]] <- x

                 else right[p[y]] <- x

if y!=z

      then key[z] <- key[y]

if color[y]=BLACK

      then RB-DELETE-FIXUP(T,x)

return y

 

这里，x为y删除后替换上去的一个节点。如果x为红色的话，那么只要将x变为黑色即可。

但是如果x为黑色的话，情况就复杂了。仍然有两组情况，一是x为p[x]的左儿子，一是x为p[x]的右儿子。仅讨论x是p[x]左儿子的情况。

设w为x的兄弟节点，即w为p[x]的右儿子，且w一定不是nil[T]，否则原来的红黑树中不满足性质5。

分四种情况讨论：

Case1： w是红色的。这种情况下，p[x]一定为黑色的。w的左右儿子一定是黑色的，将Case1转换为Case2的情况，对以p[x]为根的树进行左旋，将p[x]设为红色，原来的w设为黑色，则红黑性质保持，且问题转换为Case2,3,或4。

 

Case2: w是黑色的，如果w的两个儿子都是黑色的，那么将w改为红色，那么从p[x]出发经过左儿子到叶子节点的路径上与经过右儿子到叶子节点的路径上的黑色节点个数相同了（因为删去y后，左边的路径上的黑节点少掉了一个，而把w的颜色改掉后，右边的路径上的黑节点也少了一个，因此数量仍旧相等），但是对p[p[x]]而言，经过p[x]的路径上的黑色节点的个数少了一个，又必须重新保持红黑树性质。因此，此时x新指向p[x]，并重新循环。这种情况简单的说，就是左边少了个黑色，所以右边也减去个黑色的，然后整体就少了个黑色的，因此循环下去。

 

Case3: w是黑色的，w的左儿子是红色的，右儿子是黑色的。对以w为根的树进行右旋，将left[w]设为黑色的，w设为红色，新的w指向原来的left[w]，问题转变为Case4。

 

Case4：w是黑色的，w的右儿子是红色的。通过改变一些节点的颜色，并执行一次左旋，可以将x的额外的黑色去除。这种情况就是左边少了个黑色的，然后往左边又加个黑色的。

 

 

伪代码

RB-DELETE-FIXUP(T,z)

while x!=root[T] and color[x]=BLACK

      do if x=left[p[x]]

                 then w <- right[p[x]]

                      if color[w]=RED

                            then color[w] <- BLACK

                                    color[p[x]] <- RED

                                    LEFT-ROTATE(T,p[x])

                                    w <- right[p[x]]

                      if color[left[w]]=BLACK and color[right[w]]=BLACK

                            then color[w] <- RED

                                    x <- p[x]

                      else

                            then if color[right[w]]=BLACK

                                       then color[left[w]] <- BLACK

                                               color[w] <- RED

                                               RIGHT-ROTATE(T,w)

                                               w <- right[p[x]]

                                   color[w] <- color[p[x]]

                                   color[p[x]] <- BLACK

                                   color[right[w]] <- BLACK

                                   LEFT-ROTATE(T,p[x])

                                   x <- root[T]

         else (same as then clause with “right” and “left” exchanged)

color[x] <- BLACK

 

附录：

C++代码

#include <iostream>
using namespace std;

typedef enum col{RED, BLACK} col;

template <class T>
class RBNode
{
public:
	RBNode(T k, RBNode<T> *l=NULL, RBNode<T> *r=NULL, RBNode<T> *p=NULL
		):key(k),left(l),right(r),parent(p){}
	~RBNode();
	T key;
	RBNode<T> *left, *right, *parent;
	col color;
};

template <class T>
class RBTree
{
public:
	RBTree(RBNode<T> *r=NULL):root(r){
		NIL=new RBNode<T>(-1);
		NIL->color=BLACK;
		root->color=BLACK;
		root->left=NIL;
		root->right=NIL;
		root->parent=NIL;
	}
	~RBTree();
	void inorder(RBNode<T> *);
	RBNode<T>* search(T k, RBNode<T> *x);
	RBNode<T>* min(RBNode<T> *x);
	RBNode<T>* max(RBNode<T> *x);
	RBNode<T>* successor(RBNode<T> *x);
	void rightRotate(RBNode<T> *z);
	void leftRotate(RBNode<T> *z);
	void Insert(RBNode<T> *z);
	void Insert_fixup(RBNode<T> *x);
	void Delete(RBNode<T> *z);
	void Delete_fixup(RBNode<T> *x);
	RBNode<T> *root;
	RBNode<T> *NIL;
};

template <class T>
void RBTree<T>::inorder(RBNode<T> *x)
{
	if(x==NIL)
		return;
	inorder(x->left);
	cout << x->key << " ";
	inorder(x->right);
}

template <class T>
RBNode<T>* RBTree<T>::search(T k, RBNode<T> *x)
{
	RBNode<T> *p=x;
	while(p!=NIL && p->key!=k)
	{
		if(k < (p->key))
			p=p->left;
		else
			p=p->right;
	}
	return p;
}

template <class T>
RBNode<T>* RBTree<T>::min(RBNode<T> *x)
{
	RBNode<T> *p=x;
	if(p==NIL)
		return NIL;
	while(p->left!=NIL)
		p=p->left;
	return p;
}

template <class T>
RBNode<T>* RBTree<T>::max(RBNode<T> *x)
{
	RBNode<T> *p=x;
	if(p==NIL)
		return NIL;
	while(p->right!=NIL)
		p=p->right;
	return p;
}

template <class T>
RBNode<T>* RBTree<T>::successor(RBNode<T> *x)
{
	if(x->right!=NIL)
		return min(x->right);
	RBNode<T> *y=x;
	RBNode<T> *p=x->parent;
	while(p!=NIL && p->right==y)
	{
		y=p;
		p=p->parent;
	}
	return p;
}

template <class T>
void RBTree<T>::leftRotate(RBNode<T> *z)
{
	RBNode<T> *y=z->right;
	if(y->left!=NIL)
		y->left->parent=z;
	y->parent=z->parent;
	if(y->parent==NIL)
		root=y;
	else if(z==z->parent->left)
		z->parent->left=y;
	else
		z->parent->right=y;
	z->right=y->left;
	z->parent=y;
	y->left=z;
}

template <class T>
void RBTree<T>::rightRotate(RBNode<T> *z)
{
	RBNode<T> *y=z->left;
	y->parent=z->parent;
	if(y->parent==NIL)
		root=y;
	else if(z==z->parent->left)
		z->parent->left=y;
	else
		z->parent->right=y;
	if(y->right!=NIL)
		y->right->parent=z;
	z->left=y->right;
	y->right=z;
	z->parent=y;
}

template <class T>
void RBTree<T>::Insert(RBNode<T> *z)
{
	RBNode<T> *y=root;
	RBNode<T> *x;
	while(y!=NIL)
	{
		x=y;
		if(z->key < y->key)
			y=y->left;
		else
			y=y->right;
	}
	z->parent=x;
	if(x==NIL)
		root=z;
	else if(z->key < x->key)
		x->left=z;
	else
		x->right=z;
	z->color=RED;
	z->left=NIL;
	z->right=NIL;
	Insert_fixup(z);
}

template <class T>
void RBTree<T>::Insert_fixup(RBNode<T> *z)
{
	RBNode<T> *x=z;
	RBNode<T> *w;
	while(x->parent->color==RED)
	{
		if(x->parent==x->parent->parent->left)
		{
			w=x->parent->parent->right;
			if(w->color==RED)
			{
				w->color=BLACK;
				x->parent->color=BLACK;
				x->parent->parent->color=RED;
				x=x->parent->parent;
			}
			else
			{
				if(x==x->parent->right)
				{
					x=x->parent;
					leftRotate(x);
				}
				x->parent->color=BLACK;
				x->parent->parent->color=RED;
				rightRotate(x->parent->parent);
			}
		}
		else
		{
			w=x->parent->parent->left;
			if(w->color==RED)
			{
				w->color=BLACK;
				x->parent->color=BLACK;
				x->parent->parent->color=RED;
				x=x->parent->parent;
			}
			else
			{
				if(x==x->parent->left)
				{
					x=x->parent;
					rightRotate(x);
				}
				x->parent->color=BLACK;
				x->parent->parent->color=RED;
				leftRotate(x->parent->parent);
			}
		}
	}
	root->color=BLACK;
}

template <class T>
void RBTree<T>::Delete(RBNode<T> *z)
{
	RBNode<T> *y;
	RBNode<T> *x;
	if(z->left==NIL || z->right==NIL)
		y=z;
	else
		y=successor(z);
	if(y->left!=NIL)
		x=y->left;
	else
		x=y->right;
	x->parent=y->parent;
	if(y->parent==NIL)
		root=x;
	else if(y==y->parent->left)
		y->parent->left=x;
	else
		y->parent->right=x;
	if(y!=z)
		z->key=y->key;
	if(y->color==BLACK)
		Delete_fixup(x);
}

template <class T>
void RBTree<T>::Delete_fixup(RBNode<T> *z)
{
	RBNode<T> *x=z;
	RBNode<T> *w;
	while(x->color==BLACK && x!=root)
	{
		if(x==x->parent->left)
		{
			w=x->parent->right;
			if(w->color==RED)
			{
				w->color=BLACK;
				x->parent->color=RED;
				leftRotate(x->parent);
				w=x->parent->right;
			}
 			if(w->left->color==BLACK && w->right->color==BLACK)
			{
				w->color=RED;
				x=x->parent;
			}
			else 
			{
				if(w->right->color==BLACK)
				{
					w->color=RED;
					w->left->color=BLACK;
					w=w->left;
					rightRotate(w->parent);
				}
				w->right->color=BLACK;
				w->color=w->parent->color;
				x->parent->color=BLACK;
				leftRotate(x->parent);
				x=root;
			}
		}
		else
		{
			w=x->parent->left;
			if(w->color==RED)
			{
				w->color=BLACK;
				x->parent->color=RED;
				rightRotate(x->parent);
				w=x->parent->left;
			}
			if(w->left->color==BLACK && w->right->color==BLACK)
			{
				w->color=RED;
				x=x->parent;
			}
			else 
			{
				if(w->left->color==BLACK)
				{
					w->color=RED;
					w->right->color=BLACK;
					w=w->right;
					leftRotate(w->parent);
				}
				w->left->color=BLACK;
				w->color=w->parent->color;
				x->parent->color=BLACK;
				rightRotate(x->parent);
				x=root;
			}
		}
	}
	x->color=BLACK;
}

int main()
{
	RBNode<int>* a1=new RBNode<int>(6);
	RBNode<int>* a2=new RBNode<int>(5);
	RBNode<int>* a3=new RBNode<int>(4);
	RBNode<int>* a4=new RBNode<int>(3);
	RBNode<int>* a5=new RBNode<int>(2);
	RBNode<int>* a6=new RBNode<int>(1);

	RBTree<int> *T=new RBTree<int> (a1);
	T->inorder(T->root);
	cout << endl;
	
	T->Insert(a2);
	T->Insert(a3);
	T->Insert(a4);
	T->Insert(a5);
	T->Insert(a6);

	RBNode<int> *p=T->search(4,T->root);
	T->Delete(p);

	T->inorder(T->root);
	cout << endl;

	T->Delete(a6);
	T->Delete(a5);
	T->Delete(a4);
	T->Delete(a2);
	T->inorder(T->root);
	cout << endl;

	T->Delete(a1);
	T->inorder(T->root);
}



 

koudaidai
关注
专栏目录
红黑树（图文详解+C语言200行代码实现）
zhao_Tao_WA的博客
07-04 3598
本文以图文形式详细介绍了红黑树的性质以及各种调整策略，包括插入调整和删除调整，最后以200行精简的C语言代码实现了红黑树
红黑树定义及其代码实现
公众号：风景邮递Yuan的博客
06-16 789
红黑树是一种自平衡二叉查找树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是红色或黑色。通过对任何一条从根到叶子节点的路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出两倍，因此，红黑树是近似平衡的。5. 对于每个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点。4. 如果一个节点是红色的，则它的两个子节点都是黑色的。3. 每个叶子节点（NIL节点，空节点）是黑色的。1. 每个节点要么是红色，要么是黑色。2. 根节点是黑色的。
红黑树代码（c++，基于struct而非class）
ybszzz的博客
10-06 1027
if ((*root)->right == nullptr || (*root)->right->nodecolor==black)//叔叔节点是黑色，做节点变换。if ((*root)->left == nullptr || (*root)->left->nodecolor == black)//叔叔节点是黑色，做节点变换。else if ((*root)->right->nodecolor == red)//叔叔节点是红色，将叔叔父亲和爷爷全部变色。
红黑树的原理及代码实现
qq_52093121的博客
06-28 1207
红黑树的原理这篇博文讲解的很详细了，不熟悉红黑树的定义可以看看：红黑树的详细原理讲解咱们直接进入代码实现讲解：创建一棵红黑树，先从创建红黑树的节点开始： 1.红黑树首先是一个二叉树，所以需要一个左儿子节点的指针，右儿子节点的指针 2.红黑树是有BALCK和RED两种颜色的，所以每个节点应该有颜色 3.红黑树是Key-Value存储的 4.因为之后要进行旋转等调整，所以还需要一个父节点的信息 所以红黑树节点定义如下： 2.创建红黑树整体结构 红黑树有五个性质： 为了方便整棵红黑树的维护，我们默认叶子节点是空
红黑树实现代码+详细注释
ltrbless的博客
05-19 1622
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
红黑树原理详解及代码实现
CodePanda@GPF的博客
05-23 2916
红黑树原理及代码实践
红黑树代码详解，参考零声学院
最新发布
11-03
红黑树代码详解，参考零声学院
红黑树代码实现及分析2
02-25
在"红黑树代码实现及分析"这个主题中，你可以找到关于红黑树的具体实现细节，包括如何初始化树、插入和删除节点的步骤，以及如何进行颜色翻转和旋转等操作。通过分析这些代码，你可以更好地理解红黑树的工作原理，并...
红黑树内容及代码实现
m0_56821563的博客
07-02 419
本篇博客讲述了数据结构中红黑树的概念，并给出C++的实现。
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2534
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
红黑树实现源码
07-22
关于红黑树的功能实现
补档：红黑树代码实现+简略讲解
to_upper的博客
03-02 815
红黑树
红黑树 图文详解与代码实现
qq_54831038的博客
09-01 1521
红黑树被应用于数据结构map/set的封装的底层，也应用于Linux的数据内核，在进程调度CFS，虚拟内存管理，共享内存slab等场景都有广泛应用。数据结构的角度看，（1）用于存储。无论数据是否平衡都可以在O（logN)的复杂度下完成 搜索、插入、删除操作。（2）用于排序。找到最小值和最大值红黑树黑色和红色 也可看成两种状态，红黑区分的状态中，可以根据实际需求添加业务逻辑。......
11.1红黑树的复习
pc的博客
02-07 196
红黑树产生的原因： 之前我们学习过二叉查找树,大部分情况下,发现它的查询效率比单纯的链表和数组的查询效率要高很多(二叉查找树相当于二分查找) 但如果按顺序插入的9,8,7,6,5,4,3,2,1 会发现二叉树变成链表样子，如果我们要查找1这个元素，查找的效率依旧会很低 效率低的原因在于这个树并不平衡，为了保证查找树的平衡性，引入2-3路平衡查找树与红黑树 但2-3查找树实现起来比较复杂，而且添加数据或删除数据的时候，为维护平衡问题可能会使得效率降低，所以引入红黑树 红黑树主要是对2-3树进行编码，红黑树
[C++]——红黑树（附源码）
麦麦的博客
10-28 2513
本文为大家进行了红黑树的讲解，关于其定义、性质以及如何插入等等
数据结构之红黑树的生成、添加以及删除详解（附代码）
any_ways的博客
12-28 1555
要了解红黑树，那必须得了解它的。
c语言红黑树代码
05-29
以下是一个简单的 C 语言红黑树代码示例： ```c #include #include // 定义红黑树节点结构体 typedef struct RBNode { int data; int color; struct RBNode *left; struct RBNode *right; struct RBNode *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值