当前位置:   article > 正文

红黑树(一)的原理和算法详细介绍_红黑树算法

红黑树算法

红黑树的原理和算法的详细介绍


概要

如果想直接看红黑树的Java实现代码或者想看全部源码,
那就请先去看下一章
红黑树(二)之Java实现

所有相关代码都在这篇文章中以及Java的红黑树源代码以及测试结果,
但是还是希望各位能先看本章了解红黑树的原理再去看代码,千万不要直接去看代码,心急吃不了热豆腐哟!!!只是个人建议而已。

在学习本章之前建议已经有数据结构的基础,并且对二叉树以及AVLTree(平衡二叉树)有一定的理解,没有基础的建议先学习本章之前的知识!

概述:R-B Tree,又称为“红黑树”。本文参考了《算法导论》中红黑树相关知识,加之自己的理解,然后以图文的形式对红黑树进行说明。本文的主要内容包括:红黑树的特性,应用场景,时间复杂度,以及红黑树的左旋、右旋、插入、删除等操作的相关算法实现
还是那句老话,红黑树的C/C++/Java实现的原理一样,择其一了解即可


一、R-B Tree简介

R-B Tree,全称是Red-Black Tree,又称为“红黑树”,它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色,可以是红(Red)或黑(Black)。

红黑树的特性(规则):

(1)每个节点或者是黑色(Black),或者是红色(Red)。
(2)根节点是黑色(Black)。
(3)每个叶子节点(NIL)是黑色。 [注意:这里叶子节点,是指为空(NILNULL)的叶子节点!]
(4)如果一个节点是红色的,则它的子节点必须是黑色的。
(5)从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

注意
(01) 特性(3)中的叶子节点,是只为空(NIL或null)的节点。
(02) 特性(5),确保没有一条路径会比其他路径长出俩倍。因而,红黑树是相对是接近平衡的二叉树。

因此,满足以上五条特性的二叉树就叫做红黑树

红黑树示意图如下:
建议根据以上红黑树的五条特性查看:
在这里插入图片描述


二、R-B Tree应用场景及时间复杂度

红黑树的应用比较广泛,主要是用它来存储有序的数据,它的时间复杂度是O(lgn),效率非常之高。

  • Java ConcurrentHashMap & TreeMap
  • C++ STL: map & set
  • linux进程调度Completely Fair Scheduler,用红黑树管理进程控制块
  • epoll在内核中的实现,用红黑树管理事件块
  • nginx中,用红黑树管理timer等

多啰嗦两句。可以直接忽略不看,不重要,也可以了解

我们在学习本文章之前应该认识到了平衡二叉树(AVLTree),了解到AVL树的性质,其实平衡二叉树最大的作用就是查找,AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。AVL树的效率就是高在这个地方。如果在AVL树中插入或删除节点后,使得高度之差大于1。此时,AVL树的平衡状态就被破坏,它就不再是一棵二叉树;为了让它重新维持在一个平衡状态,就需要对其进行旋转处理, 那么创建一颗平衡二叉树的成本其实不小. 这个时候就有人开始思考,并且提出了红黑树的理论,那么红黑树到底比AVL树好在哪里?

红黑树与AVL树的比较:

  • 1.AVL树的时间复杂度虽然优于红黑树,但是对于现在的计算机,cpu太快,可以忽略性能差异
  • 2.红黑树的插入删除比AVL树更便于控制操作
  • 3.红黑树整体性能略优于AVL树(红黑树旋转情况少于AVL树)

因此我们可以知道其实红黑树就是对于AVL树的优化,牺牲了一定的严格平衡换取插入和删除时进行的频繁旋转操作,实现整体优化

并且
红黑树插入时的不平衡,不超过两次旋转就可以解决;删除时的不平衡,不超过三次旋转就能解决
红黑树的红黑规则,保证最坏的情况下,也能在 O(log2N)时间内完成查找操作。

所以在现在这个追求性能,看重速度的大数据时代,我们底层不用红黑树用AVL树那不是呆子吗?哈哈哈,开个玩笑!!!


三、R-B Tree的基本操作(一) 左旋和右旋

红黑树的基本操作也算是核心操作是添加、删除。在对红黑树进行添加或删除之后,都会用到旋转方法。为什么呢?道理很简单,添加或删除红黑树中的节点之后,红黑树就发生了变化,可能不满足红黑树的5条性质,也就不再是一颗红黑树了,而是一颗普通的树。而通过旋转,可以使这颗树重新成为红黑树。简单点说,旋转的目的是让树保持红黑树的特性。
旋转包括两种:左旋右旋。下面分别对它们进行介绍。

1、左旋

在这里插入图片描述
对x节点进行左旋,意味着’将x变成x的右孩子节点的左孩子节点‘。

左旋的伪代码《算法导论》:参考上面的示意图和下面的伪代码,理解“红黑树T的节点x进行左旋”是如何进行的。
伪代码摘自《算法导论》

LEFT-ROTATE(T, x)  
01  y ← right[x]            // 前提:这里假设x的右孩子为y。下面开始正式操作
02  right[x] ← left[y]      // 将 “y的左孩子” 设为 “x的右孩子”,即 将β设为x的右孩子
03  p[left[y]] ← x          // 将 “x” 设为 “y的左孩子的父亲”,即 将β的父亲设为x
04  p[y] ← p[x]             // 将 “x的父亲” 设为 “y的父亲”
05  if p[x] = nil[T]       
06  then root[T] ← y                 // 情况1:如果 “x的父亲” 是空节点,则将y设为根节点
07  else if x = left[p[x]]  
08            then left[p[x]] ← y    // 情况2:如果 x是它父节点的左孩子,则将y设为“x的父节点的左孩子”
09            else right[p[x]] ← y   // 情况3:(x是它父节点的右孩子) 将y设为“x的父节点的右孩子”
10  left[y] ← x             // 将 “x” 设为 “y的左孩子”
11  p[x] ← y                // 将 “x的父节点” 设为 “y

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

理解左旋的原理之后,再看一个更鲜明的示意图例子,你可以自己尝试一下操作。
在这里插入图片描述

 

2、右旋

在这里插入图片描述
对x节点进行右旋,意味着’将x变成x的左孩子节点的右孩子节点‘。

右旋的伪代码《算法导论》:参考上面的示意图和下面的伪代码,理解“红黑树T的节点y进行右旋”是如何进行的。
伪代码摘自《算法导论》

RIGHT-ROTATE(T, y)  
01  x ← left[y]             // 前提:这里假设y的左孩子为x。下面开始正式操作
02  left[y] ← right[x]      // 将 “x的右孩子” 设为 “y的左孩子”,即 将β设为y的左孩子
03  p[right[x]] ← y         // 将 “y” 设为 “x的右孩子的父亲”,即 将β的父亲设为y
04  p[x] ← p[y]             // 将 “y的父亲” 设为 “x的父亲”
05  if p[y] = nil[T]       
06  then root[T] ← x                 // 情况1:如果 “y的父亲” 是空节点,则将x设为根节点
07  else if y = right[p[y]]  
08            then right[p[y]] ← x   // 情况2:如果 y是它父节点的右孩子,则将x设为“y的父节点的左孩子”
09            else left[p[y]] ← x    // 情况3:(y是它父节点的左孩子) 将x设为“y的父节点的左孩子”
10  right[x] ← y            // 将 “y” 设为 “x的右孩子”
11  p[y] ← x                // 将 “y的父节点” 设为 “x”
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

与左旋一样,理解右旋的原理之后,再看一个更鲜明的示意图例子,你可以自己尝试一下操作。
在这里插入图片描述

旋转总结:
 左旋 和 右旋 是相对的两个概念,原理类似。理解一个也就理解了另一个。教一个小技巧,你可以只理解其中一个,左旋或者右旋,另外一个呢原理代码基本一样,如果你只写了左旋的代码,那么右旋的代码你可以不用写,只将左旋中的left改为rightright改为left即可!!!,右旋同理。

是不是非常简单,到这里左旋和右旋的算法就差不多整明白了,没有的话在多回味几遍并自己动手试试!!!


四、R-B Tree的基本操作(二) 添加

1、添加

将一个节点插入到红黑树中,需要执行哪些步骤呢?首先,将红黑树当作一颗二叉查找树,将节点插入;然后,将节点着色为红色;最后,通过旋转和重新着色等方法来修正该树,使之重新成为一颗红黑树。详细描述如下:

第一步:将红黑树当作一颗二叉查找树,将节点插入
 红黑树的本质也是一颗二叉查找树,所以无论是进行旋转还是进行修正上色都不能否认它是一棵二叉查找树,所以既然如此按照平常二叉查找树的方式进行节点插入就行,如果已经掌握二叉查找树的插入算法,这里可以粗略看看就行。

第二步:将节点着色为红色
 这里有个小细节很重要,一定要切记每次插入的新节点一定着色为红色,这是为什么呢?想必有些大神们或者大佬们已经想到了,还记得什么是红黑树吗?那还记得在R-B Tree简介中说到的红黑树的五大特性吗?看来还得在这放一下,唉!!

(1)每个节点或者是黑色(Black),或者是红色(Red)。
(2)根节点是黑色(Black)。
(3)每个叶子节点(NIL)是黑色。 [注意:这里叶子节点,是指为空(NILNULL)的叶子节点!]
(4)如果一个节点是红色的,则它的子节点必须是黑色的。
(5)从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

为什么着色为红色?
各位老铁们想想昂,咱再这里假设一下:
如果每次插入节点为黑色的话,首先要看看有没有违背这五条特性,首先(1),(2),(3),(4)不会影响,但是(5)一定会影响。

如果每次插入节点为红色的话,同样首先(1),(2),(3),(5)不会影响,(4)特性是可能会受影响的,所以明白了吗?

第三步:通过旋转和重新着色等方法来修正该树,使之重新成为一颗红黑树
 第二步中我们已经说为什么每次着色为红色的原因了,其实都是本着能违反最少特性的情况下,这样我们需要处理的情况也少了很多,所以如果违背特性(4)就进入修正通过旋转和重新着色使之重新成为一颗红黑树。

 
说了这么多,来看看添加的伪代码吧!
 

 
添加操作的伪代码《算法导论》
伪代码摘自《算法导论》

RB-INSERT(T, z)  
01  y ← nil[T]                        // 新建节点“y”,将y设为空节点。
02  x ← root[T]                       // 设“红黑树T”的根节点为“x”
03  while x ≠ nil[T]                  // 找出要插入的节点“z”在二叉树T中的位置“y”
04      do y ← x                      
05         if key[z] < key[x]  
06            then x ← left[x]  
07            else x ← right[x]  
08  p[z] ← y                          // 设置 “z的父亲” 为 “y”
09  if y = nil[T]                     
10     then root[T] ← z               // 情况1:若y是空节点,则将z设为根
11     else if key[z] < key[y]        
12             then left[y] ← z       // 情况2:若“z所包含的值” < “y所包含的值”,则将z设为“y的左孩子”
13             else right[y] ← z      // 情况3:(“z所包含的值” >= “y所包含的值”)将z设为“y的右孩子” 
14  left[z] ← nil[T]                  // z的左孩子设为空
15  right[z] ← nil[T]                 // z的右孩子设为空。至此,已经完成将“节点z插入到二叉树”中了。
16  color[z] ← RED                    // 将z着色为“红色”
17  RB-INSERT-FIXUP(T, z)             // 通过RB-INSERT-FIXUP对红黑树的节点进行颜色修改以及旋转,让树T仍然是一颗红黑树
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 

2、添加修正

上面介绍了红黑树插入节点的一些步骤,相信大家应该对如何插入数据有一定的理解,也说了一些关于违背红黑树特性需要通过旋转和重新着色进行修正,说的不多,不过,没关系,这里会多说,哈哈哈!!!开个玩笑,不然我现在打字打的整个人都快麻了,体会到写文章的痛。

添加修正这里有点绕,请各位打起十二分的精神来,

根据被插入节点的父节点的情况,可以将"当节点z被着色为红色节点,并插入二叉树"划分为三种情况来处理。

① 情况说明:被插入节点是根节点
  处理方法:直接将此节点涂成黑色

② 情况说明:被插入节点的父节点为黑色
  处理方法:什么都不需要做

② 情况说明:被插入节点的父节点为红色
  处理方法:那么,该情况与红黑树的“特性(4)”相冲突。这种情况下,被插入节点是一定存在非空祖父节点的,最起码祖父节点为根节点,这一点大家好好想想;然后进一步的讲,被插入节点也一定存在叔叔节点(即使叔叔节点为空,我们也视之为存在,空节点本身就是黑色节点)。理解这点之后,我们依据"叔叔节点的情况",将这种情况进一步划分为3种情况(Case)。

挺住大家,虽然情况分很多种,但是都简单,咬咬牙,就学会了,加油,打工人!!!在这里本作者给大家点鼓励。

情况现象说明处理策略
Case 1当前节点的父节点是红色,且当前节点的祖父节点的另一个子节点(叔叔节点)也是红色(01) 将“父节点”设为黑色。(02) 将“叔叔节点”设为黑色。(03) 将“祖父节点”设为“红色”。(04) 将“祖父节点”设为“当前节点”(红色节点);即,之后继续对“当前节点”进行操作。
Case 2当前节点的父节点是红色,叔叔节点是黑色,且当前节点是其父节点的右孩子(01) 将“父节点”作为“新的当前节点”。(02) 以“新的当前节点”为支点进行左旋。
Case 3当前节点的父节点是红色,叔叔节点是黑色,且当前节点是其父节点的左孩子(01) 将“父节点”设为“黑色”。(02) 将“祖父节点”设为“红色”。(03) 以“祖父节点”为支点进行右旋。

虽然分了三种情况,但是都好理解,针对以上这三种情况,大家也可以多想想,都学到这了,坚持住。

上面三种情况(Case)处理问题的核心思路都是:将红色的节点移到根节点;然后,将根节点设为黑色。下面对它们详细进行介绍。

多说一点,上面表格可以直接略过看下面详细情况。

 
1. (Case 1)叔叔是红色

1.1 现象说明
当前节点的父节点是红色,且当前节点的祖父节点的另一个子节点(叔叔节点)也是红色

1.2 处理策略
(01) 将“父节点”设为黑色。
(02) 将“叔叔节点”设为黑色。
(03) 将“祖父节点”设为“红色”。
(04) 将“祖父节点”设为“当前节点”(红色节点);即,之后继续对“当前节点”进行操作。

为什么这么处理。(建议理解的时候,通过下面的图进行对比)
当前节点”和“父节点”都是红色,违背“特性(4)”。所以,将“父节点”设置“黑色”以解决这个问题。
但是,将“父节点”由“红色”变成“黑色”之后,违背了“特性(5)”:因为,包含“父节点”的分支的黑色节点的总数增加了1。 解决这个问题的办法是:将“祖父节点”由“黑色”变成红色,同时,将“叔叔节点”由“红色”变成“黑色”。关于这里,说明几点:第一,为什么“祖父节点”之前是黑色?这个应该很容易想明白,因为在变换操作之前,该树是红黑树,“父节点”是红色,那么“祖父节点”一定是黑色。 第二,为什么将“祖父节点”由“黑色”变成红色,同时,将“叔叔节点”由“红色”变成“黑色”;能解决“包含‘父节点’的分支的黑色节点的总数增加了1”的问题。这个道理也很简单。“包含‘父节点’的分支的黑色节点的总数增加了1” 同时也意味着 “包含‘祖父节点’的分支的黑色节点的总数增加了1”,既然这样,我们通过将“祖父节点”由“黑色”变成“红色”以解决“包含‘祖父节点’的分支的黑色节点的总数增加了1”的问题; 但是,这样处理之后又会引起另一个问题“包含‘叔叔’节点的分支的黑色节点的总数减少了1”,现在我们已知“叔叔节点”是“红色”,将“叔叔节点”设为“黑色”就能解决这个问题。 所以,将“祖父节点”由“黑色”变成红色,同时,将“叔叔节点”由“红色”变成“黑色”;就解决了该问题。
按照上面的步骤处理之后:当前节点、父节点、叔叔节点之间都不会违背红黑树特性,但祖父节点却不一定。若此时,祖父节点是根节点,直接将祖父节点设为“黑色”,那就完全解决这个问题了;若祖父节点不是根节点,那我们需要将“祖父节点”设为“新的当前节点”,接着对“新的当前节点”进行分析。

1.3 示意图
在这里插入图片描述
修正后:
在这里插入图片描述
 
2. (Case 2)叔叔是黑色,且当前节点是右孩子

2.1 现象说明
当前节点(即,被插入节点)的父节点是红色,叔叔节点是黑色,且当前节点是其父节点的右孩子

2.2 处理策略
(01) 将“父节点”作为“新的当前节点”。
(02) 以“新的当前节点”为支点进行左旋。

为什么这么处理。(建议理解的时候,通过下面的图进行对比)
首先,将“父节点”作为“新的当前节点”;接着,以“新的当前节点”为支点进行左旋。 为了便于理解,我们先说明第(02)步,再说明第(01)步;为了便于说明,我们设置“父节点”的代号为F(Father),“当前节点”的代号为S(Son)。
为什么要“以F为支点进行左旋”呢?根据已知条件可知:S是F的右孩子。而之前我们说过,我们处理红黑树的核心思想:将红色的节点移到根节点;然后,将根节点设为黑色。既然是“将红色的节点移到根节点”,那就是说要不断的将破坏红黑树特性的红色节点上移(即向根方向移动)。 而S又是一个右孩子,因此,我们可以通过“左旋”来将S上移!
按照上面的步骤(以F为支点进行左旋)处理之后:若S变成了根节点,那么直接将其设为“黑色”,就完全解决问题了;若S不是根节点,那我们需要执行步骤(01),即“将F设为‘新的当前节点’”。那为什么不继续以S为新的当前节点继续处理,而需要以F为新的当前节点来进行处理呢?这是因为“左旋”之后,F变成了S的“子节点”,即S变成了F的父节点;而我们处理问题的时候,需要从下至上(由叶到根)方向进行处理;也就是说,必须先解决“孩子”的问题,再解决“父亲”的问题;所以,我们执行步骤(01):将“父节点”作为“新的当前节点”。

提示:上面的进行Case 2处理之后,就变成了Case 3的情况,所以会再次进行Case 3的处理。

2.3 示意图
在这里插入图片描述
修正后:
在这里插入图片描述

 
 
3. (Case 3)叔叔是黑色,且当前节点是左孩子

3.1 现象说明
当前节点(即,被插入节点)的父节点是红色,叔叔节点是黑色,且当前节点是其父节点的左孩子

3.2 处理策略
(01) 将“父节点”设为“黑色”。
(02) 将“祖父节点”设为“红色”。
(03) 以“祖父节点”为支点进行右旋。

为什么这么处理。(建议理解的时候,通过下面的图进行对比)
为了便于说明,我们设置“当前节点”为S(Original Son),“兄弟节点”为B(Brother),“叔叔节点”为U(Uncle),“父节点”为F(Father),祖父节点为G(Grand-Father)。
S和F都是红色,违背了红黑树的“特性(4)”,我们可以将F由“红色”变为“黑色”,就解决了“违背‘特性(4)’”的问题;但却引起了其它问题:违背特性(5),因为将F由红色改为黑色之后,所有经过F的分支的黑色节点的个数增加了1。那我们如何解决“所有经过F的分支的黑色节点的个数增加了1”的问题呢? 我们可以通过“将G由黑色变成红色”,同时“以G为支点进行右旋”来解决。

3.3 示意图
在这里插入图片描述

修正后:
在这里插入图片描述
 
 
结合伪代码以及为代码上面的说明,我们已经理解了RB-INSERT。我们现在给出 RB-INSERT-FIXUP的伪代码的说明,试着理解了RB-INSERT的伪代码说明。

添加修正操作的伪代码《算法导论》
伪代码摘自《算法导论》

RB-INSERT-FIXUP(T, z)
01 while color[p[z]] = RED                                                  // 若“当前节点(z)的父节点是红色”,则进行以下处理。
02     do if p[z] = left[p[p[z]]]                                           // 若“z的父节点”是“z的祖父节点的左孩子”,则进行以下处理。
03           then y ← right[p[p[z]]]                                        // 将y设置为“z的叔叔节点(z的祖父节点的右孩子)”
04                if color[y] = RED                                         // Case 1条件:叔叔是红色
05                   then color[p[z]] ← BLACK                    ▹ Case 1   //  (01) 将“父节点”设为黑色。
06                        color[y] ← BLACK                       ▹ Case 1   //  (02) 将“叔叔节点”设为黑色。
07                        color[p[p[z]]] ← RED                   ▹ Case 1   //  (03) 将“祖父节点”设为“红色”。
08                        z ← p[p[z]]                            ▹ Case 1   //  (04) 将“祖父节点”设为“当前节点”(红色节点)
09                   else if z = right[p[z]]                                // Case 2条件:叔叔是黑色,且当前节点是右孩子
10                           then z ← p[z]                       ▹ Case 2   //  (01) 将“父节点”作为“新的当前节点”。
11                                LEFT-ROTATE(T, z)              ▹ Case 2   //  (02) 以“新的当前节点”为支点进行左旋。
12                           color[p[z]] ← BLACK                 ▹ Case 3   // Case 3条件:叔叔是黑色,且当前节点是左孩子。(01) 将“父节点”设为“黑色”。
13                           color[p[p[z]]] ← RED                ▹ Case 3   //  (02) 将“祖父节点”设为“红色”。
14                           RIGHT-ROTATE(T, p[p[z]])            ▹ Case 3   //  (03) 以“祖父节点”为支点进行右旋。
15        else (same as then clause with "right" and "left" exchanged)      // 若“z的父节点”是“z的祖父节点的右孩子”,将上面的操作中“right”和“left”交换位置,然后依次执行。
16 color[root[T]] ← BLACK 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
各位朋友学到这,相信红黑树的原理已经掌握的差不多了,起码知道是怎么构建得了,还有最后一部分知识删除哟!也是最复杂的,相信我你都学到这了,删除自然也不在话下,相信你自己,你是最棒的,加油,加油。不要放弃,一鼓作气拿下这颗小破树!!!


五、R-B Tree的基本操作(三) 删除

1、删除

删除这里的内容比较复杂,各位要打起十二分精神来呀!!!加油

将一个节点从红黑树中删除,需要执行哪些步骤呢?首先,将红黑树当作一颗二叉查找树,将节点删除;然后,通过旋转和重新着色等方法来修正该树,使之重新成为一颗红黑树。详细描述如下:

第一步:将红黑树当作一颗二叉查找树,将节点删除。
 和常规的二叉查找树的删除步骤一样,首先分为三种情况

①被删除节点没有儿子:即为叶子节点,直接删除该节点就ok。
②被删除节点只有一个儿子:直接删除该节点,并用该节点的唯一的子节点顶替该节点的位置。
③被删除节点有两个儿子:那么,首先先找出它的后继节点;然后把“它的后继节点的内容”复制给“该节点的内容”;之后,删除“它的后继节点”。在这里,后继节点相当于替身,在将后继节点的内容复制给"被删除节点"之后,再将后继节点删除。这样就巧妙的将问题转换为"删除后继节点"的情况了,下面就考虑后继节点。 在"被删除节点"有两个非空子节点的情况下,它的后继节点不可能是双子非空。既然"的后继节点"不可能双子都非空,就意味着"该节点的后继节点"要么没有儿子,要么只有一个儿子。若没有儿子,则按"情况① "进行处理;若只有一个儿子,则按"情况② "进行处理。

第二步:通过旋转和重新着色等方法来修正该树,使之重新成为一颗红黑树。
被删除节点的颜色如果是红色,不必修正;倘若为黑色,那么就进入修正方法通过旋转和重新着色修正该树使之重新成为一棵红黑树。

删除操作的伪代码《算法导论》
伪代码摘自《算法导论》

RB-DELETE(T, z)
01 if left[z] = nil[T] or right[z] = nil[T]         
02    then y ← z                                  // 若“z的左孩子” 或 “z的右孩子”为空,则将“z”赋值给 “y”;
03    else y ← TREE-SUCCESSOR(z)                  // 否则,将“z的后继节点”赋值给 “y”。
04 if left[y] ≠ nil[T]
05    then x ← left[y]                            // 若“y的左孩子” 不为空,则将“y的左孩子” 赋值给 “x”;
06    else x ← right[y]                           // 否则,“y的右孩子” 赋值给 “x”。
07 p[x] ← p[y]                                    // 将“y的父节点” 设置为 “x的父节点”
08 if p[y] = nil[T]                               
09    then root[T] ← x                            // 情况1:若“y的父节点” 为空,则设置“x” 为 “根节点”。
10    else if y = left[p[y]]                    
11            then left[p[y]] ← x                 // 情况2:若“y是它父节点的左孩子”,则设置“x” 为 “y的父节点的左孩子”
12            else right[p[y]] ← x                // 情况3:若“y是它父节点的右孩子”,则设置“x” 为 “y的父节点的右孩子”
13 if y ≠ z                                    
14    then key[z] ← key[y]                        // 若“y的值” 赋值给 “z”。注意:这里只拷贝z的值给y,而没有拷贝z的颜色!!!
15         copy y's satellite data into z         
16 if color[y] = BLACK                            
17    then RB-DELETE-FIXUP(T, x)                  // 若“y为黑节点”,则调用
18 return y 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

 

2、删除修正

上面删除中,我们已经说了需要进入修正的条件,首先被删除节点为黑色时才会进入;如果被删除节点为红色不需要进入,因为删除之后不会影响红黑树的五大特性。
怕大家对红黑树的五大特性还不是很熟悉,那么我在受累以下在这里在放一下吧!!!

(1)每个节点或者是黑色(Black),或者是红色(Red)。
(2)根节点是黑色(Black)。
(3)每个叶子节点(NIL)是黑色。 [注意:这里叶子节点,是指为空(NILNULL)的叶子节点!]
(4)如果一个节点是红色的,则它的子节点必须是黑色的。
(5)从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

大家可以根据特性试试为什么只需要被删除节点为黑色时进入修正。

这一点理解完呢,我们在看一下删除后需要修正的三种情况

首先我们先假设x为被删除节点的代替节点。
注意:当前这三种情况都是以被删除节点为黑色且被删除节点的儿子非空的前提条件下
例子:红+黑 的意思是被删除节点的代替节点的颜色 + 被删除节点的颜色(也可以是别的颜色)
① 情况说明:x是“红+黑”节点。
  处理方法:直接将x设为黑色,就ok。

② 情况说明:x是“黑+黑”节点,且x为根。
  处理方法:什么都不用做。

③ 情况说明:x是“黑+黑”节点,且x不是根。
  处理方法:这种情况又可以划分为4种子情况。这4种子情况如下表所示:

现象说明处理策略
Case 1x是"黑+黑"节点,x的兄弟节点是红色。(此时x的父节点和x的兄弟节点的子节点都是黑节点)。(01) 将x的兄弟节点设为“黑色”。(02) 将x的父节点设为“红色”。(03) 对x的父节点进行左旋。(04) 左旋后,重新设置x的兄弟节点。
Case 2x是“黑+黑”节点,x的兄弟节点是黑色,x的兄弟节点的两个孩子都是黑色。(01) 将x的兄弟节点设为“红色”。(02) 设置“x的父节点”为“新的x节点”。
Case 3x是“黑+黑”节点,x的兄弟节点是黑色;x的兄弟节点的左孩子是红色,右孩子是黑色的。(01) 将x兄弟节点的左孩子设为“黑色”。(02) 将x兄弟节点设为“红色”。(03) 对x的兄弟节点进行右旋。(04) 右旋后,重新设置x的兄弟节点。
Case 4x是“黑+黑”节点,x的兄弟节点是黑色;x的兄弟节点的右孩子是红色的,x的兄弟节点的左孩子任意颜色。(01) 将x父节点颜色 赋值给 x的兄弟节点。(02) 将x父节点设为“黑色”。(03) 将x兄弟节点的右子节设为“黑色”。(04) 对x的父节点进行左旋。(05) 设置“x”为“根节点”。

 
1. (Case 1)x是"黑+黑"节点,x的兄弟节点是红色

1.1 现象说明
x是"黑+黑"节点,x的兄弟节点是红色。(此时x的父节点和x的兄弟节点的子节点都是黑节点)。

1.2 处理策略
(01) 将x的兄弟节点设为“黑色”。
(02) 将x的父节点设为“红色”。
(03) 对x的父节点进行左旋。
(04) 左旋后,重新设置x的兄弟节点。

为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
这样做的目的是将“Case 1”转换为“Case 2”、“Case 3”或“Case 4”,从而进行进一步的处理。对x的父节点进行左旋;左旋后,为了保持红黑树特性,就需要在左旋前“将x的兄弟节点设为黑色”,同时“将x的父节点设为红色”;左旋后,由于x的兄弟节点发生了变化,需要更新x的兄弟节点,从而进行后续处理。

1.3 示意图
在这里插入图片描述
 
 
2. (Case 2) x是"黑+黑"节点,x的兄弟节点是黑色,x的兄弟节点的两个孩子都是黑色

2.1 现象说明
x是“黑+黑”节点,x的兄弟节点是黑色,x的兄弟节点的两个孩子都是黑色。

2.2 处理策略
(01) 将x的兄弟节点设为“红色”。
(02) 设置“x的父节点”为“新的x节点”。

为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
这个情况的处理思想:是将“x中多余的一个黑色属性上移(往根方向移动)”。 x是“黑+黑”节点,我们将x由“黑+黑”节点 变成 “黑”节点,多余的一个“黑”属性移到x的父节点中,即x的父节点多出了一个黑属性(若x的父节点原先是“黑”,则此时变成了“黑+黑”;若x的父节点原先时“红”,则此时变成了“红+黑”)。 此时,需要注意的是:所有经过x的分支中黑节点个数没变化;但是,所有经过x的兄弟节点的分支中黑色节点的个数增加了1(因为x的父节点多了一个黑色属性)!为了解决这个问题,我们需要将“所有经过x的兄弟节点的分支中黑色节点的个数减1”即可,那么就可以通过“将x的兄弟节点由黑色变成红色”来实现。
经过上面的步骤(将x的兄弟节点设为红色),多余的一个颜色属性(黑色)已经跑到x的父节点中。我们需要将x的父节点设为“新的x节点”进行处理。若“新的x节点”是“黑+红”,直接将“新的x节点”设为黑色,即可完全解决该问题;若“新的x节点”是“黑+黑”,则需要对“新的x节点”进行进一步处理。

2.3 示意图
在这里插入图片描述

 
 
3. (Case 3)x是“黑+黑”节点,x的兄弟节点是黑色;x的兄弟节点的左孩子是红色,右孩子是黑色的

3.1 现象说明
x是“黑+黑”节点,x的兄弟节点是黑色;x的兄弟节点的左孩子是红色,右孩子是黑色的。

3.2 处理策略
(01) 将x兄弟节点的左孩子设为“黑色”。
(02) 将x兄弟节点设为“红色”。
(03) 对x的兄弟节点进行右旋。
(04) 右旋后,重新设置x的兄弟节点。

为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
我们处理“Case 3”的目的是为了将“Case 3”进行转换,转换成“Case 4”,从而进行进一步的处理。转换的方式是对x的兄弟节点进行右旋;为了保证右旋后,它仍然是红黑树,就需要在右旋前“将x的兄弟节点的左孩子设为黑色”,同时“将x的兄弟节点设为红色”;右旋后,由于x的兄弟节点发生了变化,需要更新x的兄弟节点,从而进行后续处理。

3.3 示意图
在这里插入图片描述

 
 
4. (Case 4)x是“黑+黑”节点,x的兄弟节点是黑色;x的兄弟节点的右孩子是红色的,x的兄弟节点的左孩子任意颜色

4.1 现象说明
x是“黑+黑”节点,x的兄弟节点是黑色;x的兄弟节点的右孩子是红色的,x的兄弟节点的左孩子任意颜色。

4.2 处理策略
(01) 将x父节点颜色 赋值给 x的兄弟节点。
(02) 将x父节点设为“黑色”。
(03) 将x兄弟节点的右子节设为“黑色”。
(04) 对x的父节点进行左旋。
(05) 设置“x”为“根节点”。

为什么要这样处理。(建议理解的时候,通过下面的图进行对比)
我们处理“Case 4”的目的是:去掉x中额外的黑色,将x变成单独的黑色。处理的方式是“:进行颜色修改,然后对x的父节点进行左旋。下面,我们来分析是如何实现的。
为了便于说明,我们设置“当前节点”为S(Original Son),“兄弟节点”为B(Brother),“兄弟节点的左孩子”为BLS(Brother’s Left Son),“兄弟节点的右孩子”为BRS(Brother’s Right Son),“父节点”为F(Father)。
我们要对F进行左旋。但在左旋前,我们需要调换F和B的颜色,并设置BRS为黑色。为什么需要这里处理呢?因为左旋后,F和BLS是父子关系,而我们已知BL是红色,如果F是红色,则违背了“特性(4)”;为了解决这一问题,我们将“F设置为黑色”。 但是,F设置为黑色之后,为了保证满足“特性(5)”,即为了保证左旋之后:
第一,“同时经过根节点和S的分支的黑色节点个数不变”。
若满足“第一”,只需要S丢弃它多余的颜色即可。因为S的颜色是“黑+黑”,而左旋后“同时经过根节点和S的分支的黑色节点个数”增加了1;现在,只需将S由“黑+黑”变成单独的“黑”节点,即可满足“第一”。
第二,“同时经过根节点和BLS的分支的黑色节点数不变”。
若满足“第二”,只需要将“F的原始颜色”赋值给B即可。之前,我们已经将“F设置为黑色”(即,将B的颜色"黑色",赋值给了F)。至此,我们算是调换了F和B的颜色。
第三,“同时经过根节点和BRS的分支的黑色节点数不变”。
在“第二”已经满足的情况下,若要满足“第三”,只需要将BRS设置为“黑色”即可。
经过,上面的处理之后。红黑树的特性全部得到的满足!接着,我们将x设为根节点,就可以跳出while循环(参考伪代码);即完成了全部处理。

至此,我们就完成了Case 4的处理。理解Case 4的核心,是了解如何“去掉当前节点额外的黑色”。

4.3 示意图
在这里插入图片描述
 
 
结合伪代码以及为代码上面的说明,先理解RB-DELETE。理解了RB-DELETE之后,接着对 RB-DELETE-FIXUP的伪代码进行说明

删除修正操作的伪代码《算法导论》
伪代码摘自《算法导论》

RB-DELETE-FIXUP(T, x)
01 while x ≠ root[T] and color[x] = BLACK  
02     do if x = left[p[x]]      
03           then w ← right[p[x]]                                             // 若 “x”是“它父节点的左孩子”,则设置 “w”为“x的叔叔”(即x为它父节点的右孩子)                                          
04                if color[w] = RED                                           // Case 1: x是“黑+黑”节点,x的兄弟节点是红色。(此时x的父节点和x的兄弟节点的子节点都是黑节点)。
05                   then color[w] ← BLACK                        ▹  Case 1   //   (01) 将x的兄弟节点设为“黑色”。
06                        color[p[x]] ← RED                       ▹  Case 1   //   (02) 将x的父节点设为“红色”。
07                        LEFT-ROTATE(T, p[x])                    ▹  Case 1   //   (03) 对x的父节点进行左旋。
08                        w ← right[p[x]]                         ▹  Case 1   //   (04) 左旋后,重新设置x的兄弟节点。
09                if color[left[w]] = BLACK and color[right[w]] = BLACK       // Case 2: x是“黑+黑”节点,x的兄弟节点是黑色,x的兄弟节点的两个孩子都是黑色。
10                   then color[w] ← RED                          ▹  Case 2   //   (01) 将x的兄弟节点设为“红色”。
11                        x ←  p[x]                               ▹  Case 2   //   (02) 设置“x的父节点”为“新的x节点”。
12                   else if color[right[w]] = BLACK                          // Case 3: x是“黑+黑”节点,x的兄弟节点是黑色;x的兄弟节点的左孩子是红色,右孩子是黑色的。
13                           then color[left[w]] ← BLACK          ▹  Case 3   //   (01) 将x兄弟节点的左孩子设为“黑色”。
14                                color[w] ← RED                  ▹  Case 3   //   (02) 将x兄弟节点设为“红色”。
15                                RIGHT-ROTATE(T, w)              ▹  Case 3   //   (03) 对x的兄弟节点进行右旋。
16                                w ← right[p[x]]                 ▹  Case 3   //   (04) 右旋后,重新设置x的兄弟节点。
17                         color[w] ← color[p[x]]                 ▹  Case 4   // Case 4: x是“黑+黑”节点,x的兄弟节点是黑色;x的兄弟节点的右孩子是红色的。(01) 将x父节点颜色 赋值给 x的兄弟节点。
18                         color[p[x]] ← BLACK                    ▹  Case 4   //   (02) 将x父节点设为“黑色”。
19                         color[right[w]] ← BLACK                ▹  Case 4   //   (03) 将x兄弟节点的右子节设为“黑色”。
20                         LEFT-ROTATE(T, p[x])                   ▹  Case 4   //   (04) 对x的父节点进行左旋。
21                         x ← root[T]                            ▹  Case 4   //   (05) 设置“x”为“根节点”。
22        else (same as then clause with "right" and "left" exchanged)        // 若 “x”是“它父节点的右孩子”,将上面的操作中“right”和“left”交换位置,然后依次执行。
23 color[x] ← BLACK   

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

总的来说Case 1 , Case 2,Case 4 在一些情况下可以通过自身的处理策略只循坏一次就能修正,当然也有可能一次循环不能完整修正,还要循坏判断符合哪种情况就继续进入哪种情况进行修正,直到修正完成为止;Case 3的处理策略是为了转化成 Case 4,这里不多说了,其实都一样的操作,只不过多一步操作,懂得都懂。我的时间有限,只能帮大家理解到这了。

  
 

总结

到此为止,红黑树的原理和算法的理论知识也算是差不多讲完了

看完本章,请继续看 红黑树(二)之Java实现,看完之后彻底拿下红黑树,以后面试手撕红黑树跟玩一样!!!

如果大家认真的看了本文章并本着看完一部分理解完一部分的态度的话,看到这相信各位已经基本了解红黑树的原理是怎么一回事了,不熟悉的话望诸位多回味几遍并自己去试试,多动手总会没错的。

在这里祝各位都能够学有所成,不负韶华,早日实现自己的目标!!!

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/2023面试高手/article/detail/682381
推荐阅读
相关标签
  

闽ICP备14008679号