学习红黑树

最新推荐文章于 2024-07-24 12:42:40 发布
最新推荐文章于 2024-07-24 12:42:40 发布
阅读量596 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法导论 红黑树 JAVA 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sck940210/article/details/23459523
版权

最近两次面试都被问到红黑树再见再见再见

从来没有深入学习过...很忧伤啊可怜可怜可怜

今天决定要入门学习一下红黑树奋斗奋斗奋斗


参考《算法导论》



红黑树是一种二叉查找树。

 定义红黑树的节点为RBTreeNode

有五个fields：key, color, left, right, parent


一棵红黑树应满足如下红黑性质：

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

2)      根节点是黑的

3)      每个叶节点（或使用哨兵代表NIL）是黑的

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

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

 

某个节点到达一个叶节点的路径上黑节点的数目为该节点的黑高度

红黑树的黑高度为其根节点的黑高度

 

一棵有n个内节点的红黑树的高度至多为2lg(n+1)

所以，红黑树上的动态集合操作可以在O(lg n)时间内实现

 

插入

要插入一个新节点到红黑树中。

先按照普通二叉查找树的方法将新节点插入树中，并设置为红色。

显然，若新加入的节点的父节点为红色，这样的操作破坏了树的红黑性质。

所以需要对节点重新染色以及对树结构的改变。

需要一个改变树结构的操作，这里称为旋转。


         旋转


旋转的伪代码参见算法导论

回到插入

新节点插入之后有三种情况

称新节点为z，节点的叔叔定义为z.getParent().getParent().getLeft()（或者改成right）；

z的祖父肯定是黑的（否则本身就不具有红黑性质，因为z的父亲是红的）。

 

1.      z的叔叔是红的

2.      z的叔叔是黑的而且z是其父亲的右孩子

3.      z的叔叔是黑的而且z是其父亲的左孩子

情况1：


将z的父亲和叔叔染成黑色，并将z的祖父染成红色（恢复了红黑性质4和5）

将z的祖父看作新的节点，继续完成对树的改造


情况2和3：


只凭改变节点颜色没办法恢复红黑性质5的，还需要对节点作旋转操作

对于情况2，将z改成z的父亲，对z作左旋变换，情况转变为情况3

对于情况3，将z的父亲染黑，z的祖父染红，对z的祖父作右旋变换。



睡觉睡觉睡觉成功一半了，继续~


删除

最后就是删除节点啦。

还是照普通二叉查找树的删除方法将节点删掉。

但是从红黑树中删除一个节点后，有可能会破坏树的红黑性质。

显然只有当删除节点为黑时，红黑性质会被破坏。

就必须对树进行改造。


若删除节点有孩子，令x是它的孩子（有两个孩子则选择左孩子）

否则x是删除节点的后继（它没有左孩子）的右孩子

如果x是红的，只需要简单的将其染黑就恢复了树的红黑性质

如果x是黑的则进入循环


分4种情况

1.x的兄弟是红的

2.x的兄弟是黑的，且x的兄弟的孩子都是黑的

3.x的兄弟是黑的，且x的右孩子是黑的（左孩子是红的）

4.x的兄弟是黑的，且x的右孩子是红的


情况1：


如果w是红的，那么x的父亲一定是黑的

将w染黑，x的父亲染红

左旋x的父亲，情况1转为情况2或3或4

w是红的，它的孩子是黑的，所以左旋之后，x的父亲的右孩子（也就是x的新兄弟）是黑的

更新w


情况2：


w的孩子都是黑的

将w染红，这样x的父亲就满足性质5了
把x的父亲作为新的x继续循环。
若新的x为红，跳出循环将其染黑就恢复了红黑性质，
若新的x为黑，则这条路径上仍少一个黑节点，继续循环


情况3：


w的右孩子是黑的（左孩子是红的）

将w的左孩子染黑（不会是NIL，NIL是黑的）

将w染红并右旋,更新w转为情况4


情况4：


将w的右孩子染黑，将w染成其父亲的颜色，将w的父亲染黑，并对其左旋

红黑性质已完全恢复

将x置为根节点以跳出循环


循环退出后不要忘了将x染黑。



从来不会组织语言。。到后面越来越乱，估计只有我自己能看懂

配合代码看吧


Java实现


RBTreeNode

package redblacktree;

public class RBTreeNode<T> {
	public final static int RED=0, BLACK=1;
	private T key;
	private int color;
	private RBTreeNode<T> left, right, parent;
	
	public T getKey(){ return key;}
	public void setKey(T key){ this.key=key;}
	
	public int getColor(){ return color;}
	public void setColor(int color){ this.color=color;}
	
	public RBTreeNode<T> getLeft(){ return left;}
	public void setLeft(RBTreeNode<T> left){ this.left=left;}

	public RBTreeNode<T> getRight(){ return right;}
	public void setRight(RBTreeNode<T> right){ this.right=right;}

	public RBTreeNode<T> getParent(){ return parent;}
	public void setParent(RBTreeNode<T> parent){ this.parent=parent;}
	
	public RBTreeNode(){ this.color=BLACK;}
	public RBTreeNode(T key){ this.key=key; this.color=BLACK;}
	public RBTreeNode(T key, int color){ this.key=key; this.color=color;}
}

RBTree

package redblacktree;

import java.util.Comparator;

public class RBTree<T> {
	private final RBTreeNode<T> NIL=new RBTreeNode<T>();
	private RBTreeNode<T> root;
	public RBTreeNode<T> getNIL(){ return NIL;}
	public RBTreeNode<T> getRoot(){ return root;}
	public void setRoot(RBTreeNode<T> root){
		this.root=root;
		root.setParent(NIL);
		root.setColor(RBTreeNode.BLACK);
	}
	public RBTree(RBTreeNode<T> root){ 
		this.root=root;
		root.setParent(NIL);
		root.setColor(RBTreeNode.BLACK);
		if(root.getLeft()==null)
			root.setLeft(NIL);
		if(root.getRight()==null)
			root.setRight(NIL);
	}
	
	public void leftRotated(RBTreeNode<T> x){
		RBTreeNode<T> y = x.getRight();
		if(y==NIL) return;
		x.setRight(y.getLeft());
		if(y.getLeft()!=NIL)
			y.getLeft().setParent(x);
		y.setParent(x.getParent());
		if(x.getParent()==NIL)
			root=y;
		else if(x==x.getParent().getLeft())
			x.getParent().setLeft(y);
		else 
			x.getParent().setRight(y);
		x.setParent(y);
		y.setLeft(x);
	}

	public void rightRotated(RBTreeNode<T> x){
		RBTreeNode<T> y = x.getLeft();
		if(y==NIL) return;
		x.setLeft(y.getRight());
		if(y.getRight()!=NIL)
			y.getRight().setParent(x);
		y.setParent(x.getParent());
		if(x.getParent()==NIL)
			root=y;
		else if(x==x.getParent().getLeft())
			x.getParent().setLeft(y);
		else 
			x.getParent().setRight(y);
		x.setParent(y);
		y.setRight(x);
	}
//	需要重载compare方法
	public void insert(RBTreeNode<T> z, Comparator<T> comparator){
		RBTreeNode<T> y=NIL, x=root;
		while(x!=NIL){
			y=x;
//			z的key小于x的key
			if(comparator.compare(z.getKey(), x.getKey())<0)
				x=x.getLeft();
			else
				x=x.getRight();
		}
		z.setParent(y);
		if(y==NIL)
			root=z;
		else if(comparator.compare(z.getKey(), y.getKey())<0)
			y.setLeft(z);
		else
			y.setRight(z);
		z.setLeft(NIL);
		z.setRight(NIL);
		z.setColor(RBTreeNode.RED);
		
		while(z.getParent().getColor()==RBTreeNode.RED){
			if(z.getParent()==z.getParent().getParent().getLeft()){
//				y是z的叔叔
				y=z.getParent().getParent().getRight();
//				分3种情况
//				情况1，z的叔叔是红的
				if(y.getColor()==RBTreeNode.RED){
//					将z的父亲和叔叔染黑
					z.getParent().setColor(RBTreeNode.BLACK);
					y.setColor(RBTreeNode.BLACK);
//					将z的祖父染红
					z.getParent().getParent().setColor(RBTreeNode.RED);
//					z的祖父作为新的z继续循环
					z=z.getParent().getParent();
				}
				else{
//					情况2，z的叔叔是黑的，且z是右孩子
					if(z==z.getParent().getRight()){
//						下面两行将情况2转为情况3
						z=z.getParent();
						leftRotated(z);
					}
//					情况3
					z.getParent().setColor(RBTreeNode.BLACK);
					z.getParent().getParent().setColor(RBTreeNode.RED);
					rightRotated(z.getParent().getParent());
				}
			}
			else{
//				y是z的叔叔
				y=z.getParent().getParent().getLeft();
//				分3种情况
//				情况1，z的叔叔是红的
				if(y.getColor()==RBTreeNode.RED){
//					将z的父亲和叔叔染黑
					z.getParent().setColor(RBTreeNode.BLACK);
					y.setColor(RBTreeNode.BLACK);
//					将z的祖父染红
					z.getParent().getParent().setColor(RBTreeNode.RED);
//					z的祖父作为新的z继续循环
					z=z.getParent().getParent();
				}
				else{
//					情况2，z的叔叔是黑的，且z是左孩子
					if(z==z.getParent().getLeft()){
//						下面两行将情况2转为情况3
						z=z.getParent();
						rightRotated(z);
					}
//					情况3
					z.getParent().setColor(RBTreeNode.BLACK);
					z.getParent().getParent().setColor(RBTreeNode.RED);
					leftRotated(z.getParent().getParent());
				}
			}
		}
//		最后不要忘了，把根节点染黑
		root.setColor(RBTreeNode.BLACK);
	}
	
	public RBTreeNode<T> delete(RBTreeNode<T> z){
		if(z==NIL) return NIL;
		RBTreeNode<T> x=NIL, y=NIL;
//		y不会有两个儿子
		if(z.getLeft()==NIL|| z.getRight()==NIL)
			y=z;
		else
//			z有右子树，所以y不会为NIL且y的左儿子为空
			y=succ(z);
//		这种情况下，其实y就等于z
		if(y.getLeft()!=NIL)
			x=y.getLeft();
		else
			x=y.getRight();
		x.setParent(y.getParent());
		if(y.getParent()==NIL)
			root=x;
		else if(y==y.getParent().getLeft())
			y.getParent().setLeft(x);
		else
			y.getParent().setRight(x);
		if(y!=z)
			z.setKey(y.getKey());
		if(y.getColor()==RBTreeNode.BLACK){
//			如果删除节点为黑，需要改造树
			while(x!=root && x.getColor()==RBTreeNode.BLACK){
				if(x==x.getParent().getLeft()){
//					w是x的兄弟
					RBTreeNode<T> w = x.getParent().getRight();
//					情况1：如果w是红的，那么x的父亲一定是黑的
					if(w.getColor()==RBTreeNode.RED){
//						将w染黑，x的父亲染红
						w.setColor(RBTreeNode.BLACK);
						x.getParent().setColor(RBTreeNode.RED);
//						左旋x的父亲，情况1转为情况2或3或4
//						w是红的，它的孩子是黑的，所以左旋之后，x的父亲的右孩子（也就是x的新兄弟）是黑的
						leftRotated(x.getParent());
						w=x.getParent().getRight();
					}
//					之后的情况中w一定是黑的
//					情况2:w的孩子都是黑的
					if(w.getLeft().getColor()==RBTreeNode.BLACK && w.getRight().getColor()==RBTreeNode.BLACK){
//						将w染红，这样x的父亲就满足性质5了
//						把x的父亲作为新的x继续循环。
//						若新的x为红，跳出循环将其染黑就恢复了红黑性质，
//						若新的x为黑，则这条路径上仍少一个黑节点，继续循环
						w.setColor(RBTreeNode.RED);
						x=x.getParent();
					}
					else{
//						情况3：w的右孩子是黑的（左孩子是红的）
						if(w.getRight().getColor()==RBTreeNode.BLACK){
//							将w的左孩子染黑（不会是NIL，NIL是黑的）
							w.getLeft().setColor(RBTreeNode.BLACK);
//							将w染红并右旋,更新w转为情况4
							w.setColor(RBTreeNode.RED);
							rightRotated(w);
							w=x.getParent().getRight();
						}
//						情况4
//						将w的右孩子染黑，将w染成其父亲的颜色，将w的父亲染黑，并对其左旋
						w.getRight().setColor(RBTreeNode.BLACK);
						w.setColor(w.getParent().getColor());
						w.getParent().setColor(RBTreeNode.BLACK);
						leftRotated(w.getParent());
//						红黑性质已完全恢复
						x = root;
					}
				}
				else{
//					w是x的兄弟
					RBTreeNode<T> w = x.getParent().getLeft();
//					情况1：如果w是红的，那么x的父亲一定是黑的
					if(w.getColor()==RBTreeNode.RED){
//						将w染黑，x的父亲染红
						w.setColor(RBTreeNode.BLACK);
						x.getParent().setColor(RBTreeNode.RED);
//						左旋x的父亲，情况1转为情况2或3或4
//						w是红的，它的孩子是黑的，所以右旋之后，x的父亲的左孩子（也就是x的新兄弟）是黑的
						rightRotated(x.getParent());
						w=x.getParent().getLeft();
					}
//					之后的情况中w一定是黑的
//					情况2:w的孩子都是黑的
					if(w.getLeft().getColor()==RBTreeNode.BLACK && w.getRight().getColor()==RBTreeNode.BLACK){
//						将w染红，这样x的父亲就满足性质5了
//						把x的父亲作为新的x继续循环。
//						若新的x为红，跳出循环将其染红就恢复了红黑性质，
//						若新的x为黑，则这条路径上仍少一个黑节点，继续循环
						w.setColor(RBTreeNode.RED);
						x=x.getParent();
					}
					else{
//						情况3：w的左孩子是黑的（右孩子是红的）
						if(w.getLeft().getColor()==RBTreeNode.BLACK){
//							将w的右孩子染黑（不会是NIL，NIL是黑的）
							w.getRight().setColor(RBTreeNode.BLACK);
//							将w染红并左旋,更新w转为情况4
							w.setColor(RBTreeNode.RED);
							leftRotated(w);
							w=x.getParent().getLeft();
						}
//						情况4
//						将w的左孩子染黑，将w染成其父亲的颜色，将w的父亲染黑，并对其右旋
						w.getLeft().setColor(RBTreeNode.BLACK);
						w.setColor(w.getParent().getColor());
						w.getParent().setColor(RBTreeNode.BLACK);
						rightRotated(w.getParent());
//						红黑性质已完全恢复
						x = root;
					}
				}
				x.setColor(RBTreeNode.BLACK);
			}
		}
		return y;
	}
	
	public RBTreeNode<T> succ(RBTreeNode<T> z){
//		右子树非空，则后继为右子树的最左节点
		if(z.getRight()!=NIL)
			return minimum(z.getRight());
//		右子树为空，则为z的祖先中第一个比z大的
		RBTreeNode<T> y = z.getParent();
		while(y!=NIL && z==y.getRight()){
			z=y;
			y=y.getParent();
		}
		return y;
	}
	
	public RBTreeNode<T> minimum(RBTreeNode<T> root){
		RBTreeNode<T> x = root;
		while(x.getLeft()!=NIL)
			x=x.getLeft();
		return x;
	}
	
	public static void main(String[] args){
		RBTree<Integer> tree = new RBTree<Integer>(new RBTreeNode<Integer>(0)); 
		for(int i=1; i<12; ++i){
			tree.insert(new RBTreeNode<Integer>(i), new Comparator<Integer>() {
				@Override
				public int compare(Integer arg0, Integer arg1) {
					// TODO Auto-generated method stub
					return arg0.intValue()-arg1.intValue();
				}
			});
		}
	}
}

本人对java 的学习不是很深入

这边希望大牛们指导一下

有什么简单的办法让泛型可以比较吗...

有可能这个问题本身就有问题得意得意得意





另外，红黑树的实际应用有：

Linux内核虚拟内存区域管理

STL中的map


欢迎补充~~

sck940210
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树学习
jiqiren1994的博客
09-14 334
一、红黑树简介 1972年Rudolf Bayer发明，称为平衡二叉B树（symmetric binary B-trees），在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为“红黑树”，一种特化的AVL树，在插入和删除时通过特定操作保持二叉查找树的相对平衡，从而获得较高的查找性能。 红黑树不是严格的AVL树，只是黑色平衡，如上图所示，根结点P的左子树显然比右子树高，但左子树和右子树的黑结点的层数是相等的。 二、红黑树特点 符合二叉搜索树基本特性，同时具备以下特性：
红黑树学习小记
beginend
01-05 366
红黑树的形态 红黑树是一棵带拓展节点的平衡二叉树，即某个节点若没有左儿子，则新建一个拓展节点作为左儿子。右儿子同理。拓展节点称为外部节点，其余节点称为内部节点。 每个节点被染成红色或黑色。其中 根节点必然是黑色。 外部节点必然是黑色。 内部节点可以是红色或黑色。 需要满足的性质： 每个红色节点的两个儿子必然都是黑色节点，即不存在两个相邻的红色节点。 对于任意一个节点，从它出发到其子树内的所有外部节点的路径上的黑点数量均相同。 称从节点 XXX 出发，到其子树内任意一个外部节点路径上的黑点数量为 XX
红黑树学习总结
handsome_king的博客
06-30 167
红黑树
学习红黑树心得
weixin_44765605的博客
06-14 954
红黑树 0.前言 最近看了b站一个红黑树的视频，觉得讲得很好，同时写下，看完后的心得。 视频链接：https://www.bilibili.com/video/BV135411h7wJ?p=15 红黑树演示网站：https://www.cs.usfca.edu/~galles/visualization/RedBlack.html 注意： 以下每个步骤穿插的代码只是针对某个步骤，要么是自己写的，要么是参照b站视频的老师写的。如果要看完整代码看最后。 每种情况我只讲左边或右边，因为针对左边的代码，复制一下改
红黑树学习文档
12-09
在学习红黑树的过程中，理解其性质、插入和删除操作的流程，以及如何通过旋转和重新着色来恢复平衡是非常关键的。同时，掌握Java中红黑树的具体应用，比如`TreeMap`的内部实现，有助于提升对数据结构和算法的理解和...
红黑树 学习总结
05-09
红黑树是一种近AVL树。具有以下性质： 1）结点非红即黑； 2）根节点必须为黑色； 3）任意从根到叶子的路径不包含连续的红色节点； 4）从任意结点到其所有叶子结点的路径中，包含相同的黑色结点个数。
红黑树demo python代码
07-12
通过阅读代码，你可以学习如何在实际编程中应用红黑树的平衡策略，这对于理解和优化数据结构和算法的性能至关重要。同时，这也有助于提升对二叉树和自平衡树概念的理解，这些都是计算机科学和软件工程领域的重要基础...
hongheishu.rar_红黑树
09-21
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer在1972年提出...通过阅读和分析这个项目中的代码，你可以深入学习红黑树的实现细节，并可能将其应用到自己的项目中，提高数据处理的效率。
红黑树简单实现
07-06
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。它的设计目标是在保持搜索效率的同时，通过特定的颜色规则来维护...通过本项目，我们可以学习到如何在代码中实现这些理论，并通过实践加深对红黑树的理解。
数据结构---二叉树
weixin_47808575的博客
07-22 304
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 432
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 728
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 978
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
最新发布
dab112的博客
07-24 1168
介绍了二叉搜索树的实现与模拟
Java实现七大排序（一）
lllsure的博客
07-23 515
插入排序、希尔排序、选择排序、堆排序
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 467
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
《数据结构1800题》基础回合总结——第2章 线性表
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 401
和删除第一个结点不必另作判断。另外，不论链表是否为空，链表指针不变。这个要能够表达清楚。如果不设置头结点，边界情况需要特殊处理~应用题看了一下，不想在基础回合更新了，其实程序填空各位也可以暂时忽略——主要是使插入和删除等操作统一，在第一个元素之前插入。如果能保证客观题正确率100%，这本题就没白刷~刷《1800》的意义在于，
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 327
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
学习红黑树的概念及利用python代码实现红黑树三种操作和扩张
11-08
红黑树是一种自平衡二叉查找树，它保证了在最坏情况下基本动态集合操作的时间复杂度为O(log n)。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。红黑树满足以下5个性质： 1. 每个节点要么是红色，要么是黑色...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值