遍历HashMap源码——红黑树原理、HashMap红黑树实现与反树型化（三）

本章将是HashMap源码的最后一章，将介绍红黑树及其实现，HashMap的remove方法与反树型化。长文预警~~

遍历HashMap源码——红黑树原理、HashMap红黑树实现与反树型化

什么是红黑树
- 二叉查找树
- 红黑树原理
- - 左旋
  - 右旋
  - 插入节点
  - 删除节点
HashMap的红黑树实现
反树型化

什么是红黑树

二叉查找树

理解红黑树的前提必须知道红黑树是什么。它的本质就是一个特殊的二叉查找树。那么问题来了，什么是二叉查找树？

左子树上所有结点的值均小于或等于它的根结点的值。
右子树上所有结点的值均大于或等于它的根结点的值。
左、右子树也分别为二叉排序树。

同时满足以上三个条件的，就被称为二叉查找树（BST）。
来个图看下

这就是二叉查找树的基本结构，查找一个数时，最多只需要查找树的深度次(如上图，最多只需要3次)。这个效率非常令人满意。然而，他也有一个致命的缺陷。

如上图，在极端情况下，二叉查找树这种快速查找将失效，退化成O(n)的时间复杂度。这是我们不愿意看到的。为了解决这个问题，大佬们研究出了解决方案——平衡二叉查找树（BBT）。
这里引用百度百科的解释

平衡二叉搜索树（英语：Balanced Binary Tree）是一种结构平衡的二叉搜索树，即叶节点高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。它能在O()内完成插入、查找和删除操作
在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。

阅读之后我们对BBT有了一个初步的了解，那么接下来，我们进入本章正题

红黑树原理

首先红黑树是一种弱平衡二叉树，它并没要对平衡有很苛刻的要求，这就使插入和删除节点时不用做过多的平衡转换。
至于为什么叫红黑树，这与它的实现有关。每个节点都会有一个颜色标识（红色或黑色），红黑树通过颜色标识动态平衡二叉树，接下来我们说下红黑树的5个特点：

每个节点非红即黑
根节点为黑色
每个叶子节点都是黑色 (注意：这里的叶子节点指为null或者nil的节点，非传统意义上的叶子节点)
每个红色的子节点都是黑色
任意节点到其任意叶子结点的路径上都包含相同的黑色节点 （本特点决定了任意两条路径的长度差距不会超过两倍，所以红黑树是相对平衡二叉树）

了解了上面五条规则，我们来看下红黑树是如何保持相对平衡的。
首先我们知道，打破平衡就是修改了红黑树，也就是增加和删除二叉树。如果平衡被打破，红黑树将进行自动平衡，这个过程有两个基本操作——左旋、右旋。

左旋

不难发现，左旋时B的右节点A变成了根节点，因为二叉查找树基本性质 α < λ < A 所以平衡时λ节点变为α节点的右子节点。
引用《算法导论》中一段伪代码，来实现上图的左旋

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

右旋

【手动滑稽】这里只是将左旋图进行了换位
所以原理基本和左旋相差无几，继续引用《算法导论》中伪代码，来实现上图的右旋

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

以根节点为轴，左旋逆时针，右旋顺时针~

插入节点

理解了左旋右旋的基本平衡原理，接下来我们来分析插入时的变化过程。

第一步：插入二叉查找树
当我们进行插入操作时，红黑树就是一颗普通的二叉查找树，完全按照查找树性质来比较、插入
第二部：节点着色
把新节点染成红色！Why？看红黑树规则第五条，如果新节点为红色，第五条规则将直接通过，减少了冲突发生的可能。此时就判断其他条件是否满足。
首先规则1，显然不会违背了。因为我们已经将它涂成红色了。
规则2，显然也不会违背。在第一步中，我们是将红黑树当作二叉查找树，然后执行的插入操作。而根据二叉查找数的特点，插入操作不会改变根节点。所以，根节点仍然是黑色。
规则3，显然不会违背了。这里的叶子节点是指的空叶子节点，插入非空节点并不会对它们造成影响。
规则4，是有可能违背的！
第三步：让违背规则的二叉树符合规则
这里就是整个红黑树的最重要阶段，也是最难理解的阶段 —— 如何平衡。下面是我从其他博客粘贴过来的过程，作者写的非常明白。红黑树(一)之原理和算法详细介绍 http://www.cnblogs.com/skywang12345/p/3245399.html.

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

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仍然是一颗红黑树

结合伪代码以及为代码上面的说明，先理解RB-INSERT。理解了RB-INSERT之后，我们接着对 RB-INSERT-FIXUP的伪代码进行说明。

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

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

首先我们将新节点插入红黑树分成三种状态

情况说明：被插入的节点是根节点。
处理方法：直接把此节点涂为黑色。
情况说明：被插入的节点的父节点是黑色。
处理方法：什么也不需要做。节点被插入后，仍然是红黑树。
情况说明：被插入的节点的父节点是红色。
处理方法：那么，该情况与红黑树的“规则5”相冲突。这种情况下，被插入节点是一定存在非空祖父节点的；进一步的讲，被插入节点也一定存在叔叔节点(即使叔叔节点为空，我们也视之为存在，空节点本身就是黑色节点)。理解这点之后，我们依据"叔叔节点的情况"，将这种情况进一步划分为3种情况(Case)。

	现象说明	处理策略
case1	当前节点的父节点是红色，且当前节点的祖父节点的另一个子节点（叔叔节点）也是红色。	(01) 将“父节点”设为黑色。 (02) 将“叔叔节点”设为黑色。 (03) 将祖节点”设为“红色”。 (04) 将“祖父节点”设为“当前节点”(红色节点)；即，之后继续对“当前节点”进行操作。
case2	当前节点的父节点是红色，叔叔节点是黑色，且当前节点是其父节点的右孩子	(01) 将“父节点”作为“新的当前节点”。 (02) 以“新的当前节点”为支点进行左旋。
case3	当前节点的父节点是红色，叔叔节点是黑色，且当前节点是其父节点的左孩子	(01) 将“父节点”设为“黑色”。 (02) 将“祖父节点”设为“红色”。 (03) 以“祖父节点”为支点进行右旋。

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

1.(Case 1)叔叔是红色

1.1 现象说明
当前节点(即，被插入节点)的父节点是红色，且当前节点的祖父节点的另一个子节点（叔叔节点）也是红色。

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

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

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)：将“父节点”作为“新的当前节点”。

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

第二步：通过"旋转和重新着色"等一系列来修正该树，使之重新成为一棵红黑树
因为"第一步"中删除节点之后，可能会违背红黑树的规则。所以需要通过"旋转和重新着色"来修正该树，使之重新成为一棵红黑树。
通过分析我们可以得到，删除节点可能导致树违反2、4、5三条规则，我们要想办法解决这三个问题，保证红黑树的结构合法。

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

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

结合伪代码以及为代码上面的说明，先理解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) 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

为了便于分析，我们假设"x包含一个额外的黑色"(x为顶替被删除节点的节点，x原本的颜色还存在)，这样就不会违反"规则5"。为什么呢？
通过RB-DELETE算法，我们知道：删除节点y之后，x占据了原来节点y的位置。既然删除y(y是黑色)，意味着减少一个黑色节点；那么，再在该位置上增加一个黑色即可。这样，当我们假设"x包含一个额外的黑色"，就正好弥补了"删除y所丢失的黑色节点"，也就不会违反"规则5"。因此，假设"x包含一个额外的黑色"(x原本的颜色还存在)，这样就不会违反"规则5"。
现在，x不仅包含它原本的颜色属性，x还包含一个额外的黑色。即x的颜色属性是"红+黑"或"黑+黑"，它违反了"规则1"。

现在，我们面临的问题，由解决"违反了规则(2)、(4)、(5)三个规则"转换成了"解决违反规则(1)、(2)、(4)三个规则"。RB-DELETE-FIXUP需要做的就是通过算法恢复红黑树的规则(1)、(2)、(4)。RB-DELETE-FIXUP的思想是：将x所包含的额外的黑色不断沿树上移(向根方向移动)，直到出现下面的姿态：
a) x指向一个"红+黑"节点。此时，将x设为一个"黑"节点即可。
b) x指向根。此时，将x设为一个"黑"节点即可。
c) 非前面两种姿态。

将上面的姿态，可以概括为3种情况。
① 情况说明：x是“红+黑”节点。
处理方法：直接把x设为黑色，结束。此时红黑树性质全部恢复。
② 情况说明：x是“黑+黑”节点，且x是根。
处理方法：什么都不做，结束。此时红黑树性质全部恢复。
③ 情况说明：x是“黑+黑”节点，且x不是根。
处理方法：这种情况又可以划分为4种子情况。这4种子情况如下表所示：

	现象说明	处理策略
case1	x是"黑+黑"节点，x的兄弟节点是红色。(此时x的父节点和x的兄弟节点的子节点都是黑节点)。	(01) 将x的兄弟节点设为“黑色”。 (02) 将x的父节点设为“红色”。 (03) 对x的父节点进行左旋。 (04) 左旋后，重新设置x的兄弟节点。
case2	x是“黑+黑”节点，x的兄弟节点是黑色，x的兄弟节点的两个孩子都是黑色。	(01) 将x的兄弟节点设为“红色”。 (02) 设置“x的父节点”为“新的x节点”。
case3	x是“黑+黑”节点，x的兄弟节点是黑色；x的兄弟节点的左孩子是红色，右孩子是黑色的。	(01) 将x兄弟节点的左孩子设为“黑色”。 (02) 将x兄弟节点设为“红色”。 (03) 对x的兄弟节点进行右旋。 (04) 右旋后，重新设置x的兄弟节点。
case4	x是“黑+黑”节点，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的兄弟节点，从而进行后续处理。

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节点”进行进一步处理。
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的兄弟节点，从而进行后续处理。
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的核心，是了解如何“去掉当前节点额外的黑色”。

HashMap的红黑树实现

上面我们详细说明了红黑树的基本原理，下面我们就来看看HashMap中是如何使用红黑树的。
有前两章我们知道了红黑树的入口

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V> p; int n, i;if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);else {Node<K,V> e; K k;if (p.hash == hash &&......//在此处，若已经为红黑树结构，则调用红黑树添加节点的方法else if (p instanceof TreeNode)e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);else {for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1)//在此处，若达到转化阈值，开始树型化treeifyBin(tab, hash);......}

知道了入口，我们来看下树型化的过程，即treeifyBin()方法

final void treeifyBin(Node<K,V>[] tab, int hash) {int n, index; Node<K,V> e;//若hash桶个数小于树型化最小要求（64） 不进行树型化  进行桶扩容if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();//桶内数据不为空 进入else if ((e = tab[index = (n - 1) & hash]) != null) {//TreeNode为HashMap内部类  TreeMap的结构放到了下一个代码块中//hd 头节点  tl 当前节点TreeNode<K,V> hd = null, tl = null;do {//调用replacementTreeNode方法初始化节点//这里仅仅将值写入TreeNode节点 将TreeNode的next属性设置为null 这里代码简单就不进入了TreeNode<K,V> p = replacementTreeNode(e, null);//首次循环t1 = null  进入if (tl == null)//设置头节点为phd = p;else {//将正在新建的节点的前驱节点指针指向当前节点p.prev = tl;//将当前节点next指针指向正在新建的节点tl.next = p;}//设置当前节点为ptl = p;} while ((e = e.next) != null);//设置当前桶的头节点为hdif ((tab[index] = hd) != null)//开始树型化hd.treeify(tab);}

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {TreeNode<K,V> parent;  //父节点TreeNode<K,V> left;   //左子节点TreeNode<K,V> right;   //右子节点TreeNode<K,V> prev;   //前驱节点 删除后需要取消链接boolean red;  //红黑树节点颜色标识TreeNode(int hash, K key, V val, Node<K,V> next) {super(hash, key, val, next);}//省略具体方法，涉及到的将在流程中详谈......

 final void treeify(Node<K,V>[] tab) {//定义头节点TreeNode<K,V> root = null;//遍历 x指向当前接单 next指向下一个节点for (TreeNode<K,V> x = this, next; x != null; x = next) {//next指向下一个节点next = (TreeNode<K,V>)x.next;//将当前节点左右子树清空x.left = x.right = null;//首次遍历 root为空if (root == null) {//将当前节点设置为根节点 遵守红黑树原则 根节点为黑色x.parent = null;x.red = false;root = x;}//根节点已存在  进入else {//取当前节点keyK k = x.key;//取当前节点hashint h = x.hash;//当前节点key的classClass<?> kc = null;//从根节点开始遍历for (TreeNode<K,V> p = root;;) {// dir 标识方向（左右）、ph标识当前树节点的hash值int dir, ph;//取当前节点key值K pk = p.key;//若当前树节点hash值大于链表节点hash值 标识方向为左子树if ((ph = p.hash) > h)dir = -1;//同上 小于标识为右子树else if (ph < h)dir = 1;//若当前节点key和hash都相等 则比较key的class是否相等 若依然不相等 调用compare方法比较else if ((kc == null &&(kc = comparableClassFor(k)) == null) ||(dir = compareComparables(kc, k, pk)) == 0)//程序执行到此，已经没有办法比较两个对象的大小了，java强制排序打破平衡dir = tieBreakOrder(k, pk);//保存当前树节点TreeNode<K,V> xp = p;/** 如果dir 小于等于0 ： 当前链表节点一定放置在当前树节点的左侧，但不一定是该树节点的左孩子，也可能是左孩子的右孩子 或者 更深层次的节点。* 如果dir 大于0 ： 当前链表节点一定放置在当前树节点的右侧，但不一定是该树节点的右孩子，也可能是右孩子的左孩子 或者 更深层次的节点。* 如果当前树节点不是叶子节点，那么最终会以当前树节点的左孩子或者右孩子 为 起始节点 继续本层循环 重新寻找自己（当前链表节点）的位置* 如果当前树节点就是叶子节点，那么根据dir的值，就可以把当前链表节点挂载到当前树节点的左或者右侧了。* 挂载之后，还需要重新把树进行平衡。平衡之后，就可以针对下一个链表节点进行处理了。*/if ((p = (dir <= 0) ? p.left : p.right) == null) {x.parent = xp;if (dir <= 0)xp.left = x;elsexp.right = x;//平衡操作 重新寻找根节点  具体平衡方法和红黑树原理一致，这里就不展开源码了root = balanceInsertion(root, x);break;}}}}//将红黑树的根节点作为桶内的第一个节点放入moveRootToFront(tab, root);}

以上就是树型化的全部过程，当我们理解了红黑树原理，再来看源代码时就没那么云里雾里不知所云了。HashMap对于已经树型化的put操作putTreeVal()方法和上文treeify()方法基本一致，这里也就不再赘述了。

反树型化

有第一篇我们知道，当红黑树节点小于转化阈值（6）的时候，红黑树会变回链表结构。谈到这里，我们来看看HashMap的remove()方法

 public V remove(Object key) {Node<K,V> e;//调用removeNode()return (e = removeNode(hash(key), key, null, false, true)) == null ?null : e.value;}final Node<K,V> removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {Node<K,V>[] tab; Node<K,V> p; int n, index;//当前桶不为空  hash表长度大于0  桶内节点不为空 进入if ((tab = table) != null && (n = tab.length) > 0 &&(p = tab[index = (n - 1) & hash]) != null) {Node<K,V> node = null, e; K k; V v;//当前节点与删除目标hash相等 key相等 那别找了 删的就是你  node记录当前要删除的节点if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))node = p;//若删除目标不是头节点  从头节点遍历else if ((e = p.next) != null) {//若是红黑树，调用红黑树查找方法if (p instanceof TreeNode)node = ((TreeNode<K,V>)p).getTreeNode(hash, key);else {//不是红黑树，遍历链表找到目标节点do {if (e.hash == hash &&((k = e.key) == key ||(key != null && key.equals(k)))) {node = e;break;}p = e;} while ((e = e.next) != null);}}   //如果找到了要删除的节点 且不需要验证value 或者是验证value但value相等 则开始删除if (node != null && (!matchValue || (v = node.value) == value ||(value != null && value.equals(v)))) {//若节点是红黑树节点 调用红黑树删除方法if (node instanceof TreeNode)((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);//如是链表头节点，直接将头节点指向下一个节点else if (node == p)tab[index] = node.next;//将要删除的节点的next指针赋值给上一个节点的next指针elsep.next = node.next;//修改次数 + 1++modCount;//数据量 - 1--size;//无用调用afterNodeRemoval(node);return node;}}return null;}

final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,boolean movable) {int n;if (tab == null || (n = tab.length) == 0)return;int index = (n - 1) & hash;TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;......//如果桶内根节点为空 或者桶内根节点左右子树有一个为空的 直接进行反树型化if (root == null|| (movable&& (root.right == null|| (rl = root.left) == null|| rl.left == null))) {tab[index] = first.untreeify(map);  // too small  <--- 作者说太小了return;}......}

我们惊奇的发现，反树型化是因为太小？？？说好的反树型化阈值呢，居然没发现？

我们发现反树型化只有三处调用，一个是因为too small才转化的，另外两处都是来自split()方法，而split()方法仅仅在resize()方法处调用。这也就说明了单纯的移除结点并不会使红黑树转化成链表。只有在扩容时才有可能进行反树型化。接下类我们看一下split()源码

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {TreeNode<K,V> b = this;//设置低位首节点和低位尾节点TreeNode<K,V> loHead = null, loTail = null;//设置高位首节点和高位尾节点TreeNode<K,V> hiHead = null, hiTail = null;//定义两个变量lc和hc，初始值为0，后面比较要用，他们的大小决定了红黑树是否要转回链表int lc = 0, hc = 0;//遍历红黑树for (TreeNode<K,V> e = b, next; e != null; e = next) {next = (TreeNode<K,V>)e.next;e.next = null;//位运算 此处与链表扩容位运算相同 整理出两个链表并统计长度if ((e.hash & bit) == 0) {if ((e.prev = loTail) == null)loHead = e;elseloTail.next = e;loTail = e;++lc;}else {if ((e.prev = hiTail) == null)hiHead = e;elsehiTail.next = e;hiTail = e;++hc;}}//如果低位头节点不为空if (loHead != null) {//低位链表小于阈值 反树型化if (lc <= UNTREEIFY_THRESHOLD)tab[index] = loHead.untreeify(map);//不满足，重新树型化else {tab[index] = loHead;if (hiHead != null) // (else is already treeified)loHead.treeify(tab);}}//高位同上if (hiHead != null) {if (hc <= UNTREEIFY_THRESHOLD)tab[index + bit] = hiHead.untreeify(map);else {tab[index + bit] = hiHead;if (loHead != null)hiHead.treeify(tab);}}}

     //反树型化方法仅仅是遍历然后创建的新链表，代码易读就不再说明了final Node<K,V> untreeify(HashMap<K,V> map) {Node<K,V> hd = null, tl = null;for (Node<K,V> q = this; q != null; q = q.next) {Node<K,V> p = map.replacementNode(q, null);if (tl == null)hd = p;elsetl.next = p;tl = p;}return hd;}

至此HashMap的核心内容已经梳理完毕，接下来，我们就要探索HashMap的进阶版 —— ConcurrentHashMap