逐行解读HashMap源码之红黑树篇

【稿件】

写在前面

本文是之前发表的文章《逐行解读HashMap源码》的下一篇，也是最后一篇。在《逐行解读HashMap源码》文章中，笔者主要分析了 HashMap 类的成员变量与成员方法，未涉及对 HashMap 中红黑树相关内容的分析。于是，笔者经过一段的时间的编写与打磨，写出了本文。本文主要内容包括对上一篇文章的些许补充以及对红黑树源码的详细解读。

如果读者没有阅读过上一篇内容，可以微信搜索公众号“代码艺术”搜索并阅读文章。

1. 红黑树概述

从本章节开始，笔者将对 HashMap 内部的 TreeNode 内部类源码开始分析，这部分的内容也就是我们所说的红黑树。

红黑树是建立在二叉查找树的基础之上的，二叉查找树又是建立在二叉树的基础之上。所以，我们需要从二叉树开始学习红黑树的发展脉络。

2. 二叉树

二叉树(英语：Binary tree)是每个节点最多只有两个分支(即不存在分支度大于2的节点)的树结构。通常分支被称作“左子树”或“右子树”。二叉树的分支具有左右次序，不能随意颠倒。

3. 二叉查找树

二叉查找树(英语：Binary Search Tree)，也称为二叉搜索树、有序二叉树(ordered binary tree)或排序二叉树(sorted binary tree)，是指一棵空树或者具有下列性质的二叉树：

  1. 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值;
  2. 若任意节点的右子树不空，则右子树上所有节点的值均大于或等于它的根节点的值;
  3. 任意节点的左、右子树也分别为二叉查找树;

一颗二叉查找树如下图所示：

但是，当我们顺序插入一系列节点后，二叉查找树就退化为线性表，如下图所示：

虽然二叉查找树退化为线性表之后，最坏效率降为 O(n)。但依旧有很多改进版的二叉查找树可以使树高为O(log n)，从而将最坏效率降至O(log n)，如AVL树、红黑树等。

4. AVL树

AVL 树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为 1 ，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是 O(logn)。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。

在 AVL 树中，节点的**平衡因子**是它的左子树的高度减去它的右子树的高度(有时相反)。带有平衡因子 1、0 或 -1 的节点被认为是平衡的。带有平衡因子 -2 或 2 的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。

AVL 树自平衡的方式是做一次或多次所谓的"AVL旋转"。

5. 红黑树

红黑树(英语：Red–black tree)也是一种自平衡二叉查找树。红黑树在二叉查找树的基础之上，对每个节点都增加了颜色属性，分为红色或黑色。在二叉查找树强制的一般要求以外，对于任何有效的红黑树增加了如下 5 条额外要求：

  1. 节点是红色或黑色。
  2. 根节点是黑色。
  3. 所有叶子都是黑色(叶子是NIL节点)。
  4. 每个红色节点必须有两个黑色的子节点。(从每个叶子到根的所有路径上不能有两个连续的红色节点。)
  5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

下面是一个具体的红黑树的图例：

红黑树的这些特性，保证了红黑树**从根到叶子的最长的可能路径不多于最短的可能路径的两倍长**，造成的结果是红黑树大致上是平衡的。如上图所示，"nil叶子"或"空(null)叶子"不包含数据而只充当树在此结束的指示。

对于红黑树的读与写，因为每一个红黑树都是一个(特殊的)二叉查找树，因此红黑树上的只读操作与普通二叉查找树上的只读操作相同。然而，在红黑树上进行插入操作和删除操作会导致不再符合红黑树的性质。恢复红黑树的性质需要少量 O(log n) 的颜色变更(实际是非常快速的)和不超过三次的树旋转(对于插入操作是两次)。虽然插入和删除很复杂，但操作时间仍可以保持为 O(log n) 次。

本章节开始结合 HashMap 源码讲解红黑树的插入、红黑树的删除、红黑树的自平衡、左旋、右旋等内容。

6. 链表转为红黑树的过程

HashMap 的桶类型除了 Node (链表)外，还有 TreeNode (树)。

TreeNode 类包含成员方法 `treeify()` ，该方法的作用是形成以当前 TreeNode 对象为根节点的红黑树。

树化过程不外乎是循环遍历链表，构造一颗二叉查找树，最后使用红黑树的平衡方法进行自平衡。

该方法源码如下：

 
 
 
 
    
  
  
  
  
  1. final void treeify(Node[] tab) { 
    2. 
  
  
  
  
  2. TreeNode root = null; 
    3. 
  
  
  
  
  3. // 步骤①：循环遍历当前TreeNode链表 
    4. 
  
  
  
  
  4. for (TreeNode x = this, next; x != null; x = next) { 
    5. 
  
  
  
  
  5. next = (TreeNode)x.next; 
    6. 
  
  
  
  
  6. x.left = x.right = null; 
    7. 
  
  
  
  
  7. // 步骤②：如果还未设置根节点.. 
    8. 
  
  
  
  
  8. if (root == null) { 
    9. 
  
  
  
  
  9. x.parent = null; 
    10. 
  
  
  
  
  10. x.red = false; 
    11. 
  
  
  
  
  11. root = x; 
    12. 
  
  
  
  
  12. } 
    13. 
  
  
  
  
  13. // 步骤③：如果已设置根节点.. 
    14. 
  
  
  
  
  14. else { 
    15. 
  
  
  
  
  15. K k = x.key; 
    16. 
  
  
  
  
  16. int h = x.hash; 
    17. 
  
  
  
  
  17. Class kc = null; 
    18. 
  
  
  
  
  18. // 步骤④：从根节点开始遍历，插入新节点 
    19. 
  
  
  
  
  19. for (TreeNode p = root;;) { 
    20. 
  
  
  
  
  20. int dir, ph; 
    21. 
  
  
  
  
  21. K pk = p.key; 
    22. 
  
  
  
  
  22. // 步骤⑤：比较当前节点的hash值与新节点的hash值 
    23. 
  
  
  
  
  23. // 若是新节点hash值较小 
    24. 
  
  
  
  
  24. if ((ph = p.hash) > h) 
    25. 
  
  
  
  
  25. dir = -1; 
    26. 
  
  
  
  
  26. // 若是新节点的hash值较大 
    27. 
  
  
  
  
  27. else if (ph < h) 
    28. 
  
  
  
  
  28. dir = 1; 
    29. 
  
  
  
  
  29. // 若是新节点与当前节点的hash值相等 
    30. 
  
  
  
  
  30. else if ( 
    31. 
  
  
  
  
  31. // 如果新节点的key没有实现Comparable接口.. 
    32. 
  
  
  
  
  32. (kc == null && (kc = comparableClassFor(k)) == null) 
    33. 
  
  
  
  
  33. // 或者实现了Comparable接口但是k.compareTo(pk)结果为0 
    34. 
  
  
  
  
  34. ||(dir = compareComparables(kc, k, pk)) == 0) 
    35. 
  
  
  
  
  35. // 则调用tieBreakOrder继续比较大小 
    36. 
  
  
  
  
  36. dir = tieBreakOrder(k, pk); 
    37. 
  
  
  
  
  37. TreeNode xp = p; 
    38. 
  
  
  
  
  38. // 步骤⑥：如果新节点经比较后小于等于当前节点且当前节点的左子节点为null，则插入新节点，反之亦然 
    39. 
  
  
  
  
  39. if ((p = (dir <= 0) ? p.left : p.right) == null) { 
    40. 
  
  
  
  
  40. x.parent = xp; 
    41. 
  
  
  
  
  41. if (dir <= 0) 
    42. 
  
  
  
  
  42. xp.left = x; 
    43. 
  
  
  
  
  43. else 
    44. 
  
  
  
  
  44. xp.right = x; 
    45. 
  
  
  
  
  45. // 步骤⑦：平衡红黑树 
    46. 
  
  
  
  
  46. root = balanceInsertion(root, x); 
    47. 
  
  
  
  
  47. break; 
    48. 
  
  
  
  
  48. } 
    49. 
  
  
  
  
  49. } 
    50. 
  
  
  
  
  50. } 
    51. 
  
  
  
  
  51. } 
    52. 
  
  
  
  
  52. // 步骤⑧：确保给定的根节点是所在桶的第一个节点 
    53. 
  
  
  
  
  53. moveRootToFront(tab, root); 
    54. 
  
  
  
  
  54. } 
    55.

7. 红黑树的左旋和右旋

红黑树的左旋和右旋其实很简单，所谓的左旋是把要平衡的节点向左下旋转成一个叶子节点。

如下图所示：

所谓的右旋是把要平衡的节点向右下旋转成一个叶子节点。

如下图所示：

在 HashMap 的源码中，左旋的实现代码如下：

 
 
 
 
    
  
  
  
  
  1. static TreeNode rotateLeft(TreeNode root, 
    2. 
  
  
  
  
  2. TreeNode p) { 
    3. 
  
  
  
  
  3. // p: 当前节点 
    4. 
  
  
  
  
  4. // r: 当前节点的右儿子 
    5. 
  
  
  
  
  5. // rl: 当前节点的右儿子的左儿子 
    6. 
  
  
  
  
  6. TreeNode r, pp, rl; 
    7. 
  
  
  
  
  7. // 如果当前节点和当前节点的右儿子不为空，就左旋 
    8. 
  
  
  
  
  8. if (p != null && (r = p.right) != null) { 
    9. 
  
  
  
  
  9. // 步骤①：当前节点的右儿子的左儿子成为当前节点的右儿子 
    10. 
  
  
  
  
  10. if ((rl = p.right = r.left) != null) 
    11. 
  
  
  
  
  11. rl.parent = p; 
    12. 
  
  
  
  
  12. // 步骤②：当前节点的右儿子成为当前节点的父节点 
    13. 
  
  
  
  
  13. if ((pp = r.parent = p.parent) == null) 
    14. 
  
  
  
  
  14. // 如果当前节点是根节点，那么r的颜色必须是黑色 
    15. 
  
  
  
  
  15. (root = r).red = false; 
    16. 
  
  
  
  
  16. else if (pp.left == p) 
    17. 
  
  
  
  
  17. pp.left = r; 
    18. 
  
  
  
  
  18. else 
    19. 
  
  
  
  
  19. pp.right = r; 
    20. 
  
  
  
  
  20. r.left = p; 
    21. 
  
  
  
  
  21. p.parent = r; 
    22. 
  
  
  
  
  22. } 
    23. 
  
  
  
  
  23. return root; 
    24. 
  
  
  
  
  24. } 
    25.

右旋的实现代码如下：

 
 
 
 
    
  
  
  
  
  1. static TreeNode rotateRight(TreeNode root, 
    2. 
  
  
  
  
  2. TreeNode p) { 
    3. 
  
  
  
  
  3. // p: 当前节点 
    4. 
  
  
  
  
  4. // l: 当前节点的左儿子 
    5. 
  
  
  
  
  5. // lr: 当前节点的左儿子的右儿子 
    6. 
  
  
  
  
  6. TreeNode l, pp, lr; 
    7. 
  
  
  
  
  7. // 如果当前节点和当前节点的左儿子不为空，就右旋 
    8. 
  
  
  
  
  8. if (p != null && (l = p.left) != null) { 
    9. 
  
  
  
  
  9. // 步骤①：当前节点的左儿子的右儿子成为当前节点的左儿子 
    10. 
  
  
  
  
  10. if ((lr = p.left = l.right) != null) 
    11. 
  
  
  
  
  11. lr.parent = p; 
    12. 
  
  
  
  
  12. // 步骤②：当前节点的左儿子成为当前节点的父节点 
    13. 
  
  
  
  
  13. if ((pp = l.parent = p.parent) == null) 
    14. 
  
  
  
  
  14. // 如果当前节点是根节点，那么r的颜色必须是黑色 
    15. 
  
  
  
  
  15. (root = l).red = false; 
    16. 
  
  
  
  
  16. else if (pp.right == p) 
    17. 
  
  
  
  
  17. pp.right = l; 
    18. 
  
  
  
  
  18. else 
    19. 
  
  
  
  
  19. pp.left = l; 
    20. 
  
  
  
  
  20. l.right = p; 
    21. 
  
  
  
  
  21. p.parent = l; 
    22. 
  
  
  
  
  22. } 
    23. 
  
  
  
  
  23. return root; 
    24. 
  
  
  
  
  24. } 
    25.

 8. 红黑树的插入

红黑树是一棵特殊的二叉查找树，如同二叉查找树的插入一样，红黑树的插入，也需要判断插入节点与当前节点的大小。如果插入节点大于或等于当前节点，则插入当前节点的右子树;否则，插入到左子树。循环此过程，直到找到为空的叶子节点放入即可。

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2. * Tree version of putVal. 
    3. 
  
  
  
  
  3. */ 
    4. 
  
  
  
  
  4. final TreeNode putTreeVal(HashMap map, Node[] tab, 
    5. 
  
  
  
  
  5. int h, K k, V v) { 
    6. 
  
  
  
  
  6. Class kc = null; 
    7. 
  
  
  
  
  7. boolean searched = false; 
    8. 
  
  
  
  
  8. // root: 树根节点 
    9. 
  
  
  
  
  9. TreeNode root = (parent != null) ? root() : this; 
    10. 
  
  
  
  
  10. for (TreeNode p = root;;) { 
    11. 
  
  
  
  
  11. // p: 当前节点 
    12. 
  
  
  
  
  12. // dir: 标识新节点应该插入到当前节点的左子树还是右子树 
    13. 
  
  
  
  
  13. // ph: 当前节点的hash值 
    14. 
  
  
  
  
  14. // pk: 当前节点的key 
    15. 
  
  
  
  
  15. int dir, ph; K pk; 
    16. 
  
  
  
  
  16. // 步骤①：判断新节点应该插入到当前节点的左子树还是右子树 
    17. 
  
  
  
  
  17. if ((ph = p.hash) > h) 
    18. 
  
  
  
  
  18. dir = -1; 
    19. 
  
  
  
  
  19. else if (ph < h) 
    20. 
  
  
  
  
  20. dir = 1; 
    21. 
  
  
  
  
  21. else if ((pk = p.key) == k || (k != null && k.equals(pk))) 
    22. 
  
  
  
  
  22. return p; 
    23. 
  
  
  
  
  23. else if ((kc == null && 
    24. 
  
  
  
  
  24. (kc = comparableClassFor(k)) == null) || 
    25. 
  
  
  
  
  25. (dir = compareComparables(kc, k, pk)) == 0) { 
    26. 
  
  
  
  
  26. if (!searched) { 
    27. 
  
  
  
  
  27. TreeNode q, ch; 
    28. 
  
  
  
  
  28. searched = true; 
    29. 
  
  
  
  
  29. if (((ch = p.left) != null && 
    30. 
  
  
  
  
  30. (q = ch.find(h, k, kc)) != null) || 
    31. 
  
  
  
  
  31. ((ch = p.right) != null && 
    32. 
  
  
  
  
  32. (q = ch.find(h, k, kc)) != null)) 
    33. 
  
  
  
  
  33. return q; 
    34. 
  
  
  
  
  34. } 
    35. 
  
  
  
  
  35. dir = tieBreakOrder(k, pk); 
    36. 
  
  
  
  
  36. } 
    37. 
  
  
  
  
  37. TreeNode xp = p; 
    38. 
  
  
  
  
  38. // 步骤②：终于从上向下遍历到了空的叶子节点，插入新节点 
    39. 
  
  
  
  
  39. if ((p = (dir <= 0) ? p.left : p.right) == null) { 
    40. 
  
  
  
  
  40. // 1.父节点指向新节点 
    41. 
  
  
  
  
  41. Node xpn = xp.next; 
    42. 
  
  
  
  
  42. TreeNode x = map.newTreeNode(h, k, v, xpn); 
    43. 
  
  
  
  
  43. // 新节点位置在左子树还是右子树 
    44. 
  
  
  
  
  44. if (dir <= 0) 
    45. 
  
  
  
  
  45. xp.left = x; 
    46. 
  
  
  
  
  46. else 
    47. 
  
  
  
  
  47. xp.right = x; 
    48. 
  
  
  
  
  48. xp.next = x; 
    49. 
  
  
  
  
  49. // 2.新节点指向父节点 
    50. 
  
  
  
  
  50. x.parent = x.prev = xp; 
    51. 
  
  
  
  
  51. if (xpn != null) 
    52. 
  
  
  
  
  52. // 如果有兄弟节点，兄弟节点的上一个节点指向新节点 
    53. 
  
  
  
  
  53. ((TreeNode)xpn).prev = x; 
    54. 
  
  
  
  
  54. // 最后平衡红黑树，并保证根节点在哈希桶的头部 
    55. 
  
  
  
  
  55. moveRootToFront(tab, balanceInsertion(root, x)); 
    56. 
  
  
  
  
  56. return null; 
    57. 
  
  
  
  
  57. } 
    58. 
  
  
  
  
  58. } 
    59. 
  
  
  
  
  59. } 
    60.

红黑树的插入与二叉查找树的不同之处，在于最后的平衡部分。

插入节点之后的红黑树平衡方法如下：

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2. * 平衡红黑树-当新增后 
    3. 
  
  
  
  
  3. * x: 影响平衡的点(俗称：当前节点) 
    4. 
  
  
  
  
  4. */ 
    5. 
  
  
  
  
  5. static TreeNode balanceInsertion(TreeNode root, 
    6. 
  
  
  
  
  6. TreeNode x) { 
    7. 
  
  
  
  
  7. // 新增节点x默认是红色 
    8. 
  
  
  
  
  8. x.red = true; 
    9. 
  
  
  
  
  9. // xp父节点 xpp祖父节点 xppl祖父左节点 xppr 祖父右节点(p: parent, l: left, r: right) 
    10. 
  
  
  
  
  10. for (TreeNode xp, xpp, xppl, xppr;;) { 
    11. 
  
  
  
  
  11. if ((xp = x.parent) == null) { 
    12. 
  
  
  
  
  12. // 步骤①：如果插入的是根节点，根据红黑树性质之根节点是黑色，直接涂黑即可 
    13. 
  
  
  
  
  13. x.red = false; 
    14. 
  
  
  
  
  14. return x; 
    15. 
  
  
  
  
  15. } 
    16. 
  
  
  
  
  16. // 步骤②：插入节点的父节点是黑色或者父节点是根节点，红黑树没有被破坏，不需要调整 
    17. 
  
  
  
  
  17. else if (!xp.red || (xpp = xp.parent) == null) 
    18. 
  
  
  
  
  18. return root; 
    19. 
  
  
  
  
  19. // 父节点是祖父节点的左子节点 
    20. 
  
  
  
  
  20. if (xp == (xppl = xpp.left)) { 
    21. 
  
  
  
  
  21. // 步骤③：当前节点的父节点是红色，且叔叔节点也是红色 
    22. 
  
  
  
  
  22. if ((xppr = xpp.right) != null && xppr.red) { 
    23. 
  
  
  
  
  23. // 1.叔叔节点设置为黑色 
    24. 
  
  
  
  
  24. xppr.red = false; 
    25. 
  
  
  
  
  25. // 2.父节点设置为黑色 
    26. 
  
  
  
  
  26. xp.red = false; 
    27. 
  
  
  
  
  27. // 3.祖父节点设置为红色 
    28. 
  
  
  
  
  28. xpp.red = true; 
    29. 
  
  
  
  
  29. // 4.将当前节点指向祖父节点，从新的当前节点重新开始算法 
    30. 
  
  
  
  
  30. x = xpp; 
    31. 
  
  
  
  
  31. } 
    32. 
  
  
  
  
  32. else { 
    33. 
  
  
  
  
  33. // 步骤④：当前节点的父节点是红色，且叔叔节点是黑色，当前节点是其父右子节点 
    34. 
  
  
  
  
  34. if (x == xp.right) { 
    35. 
  
  
  
  
  35. // 当前节点的父节点作为新的当前节点，以新当节点为支点左旋 
    36. 
  
  
  
  
  36. root = rotateLeft(root, x = xp); 
    37. 
  
  
  
  
  37. // 重新赋值 
    38. 
  
  
  
  
  38. xpp = (xp = x.parent) == null ? null : xp.parent; 
    39. 
  
  
  
  
  39. } 
    40. 
  
  
  
  
  40. if (xp != null) { 
    41. 
  
  
  
  
  41. // 父节点设置为黑色 
    42. 
  
  
  
  
  42. xp.red = false; 
    43. 
  
  
  
  
  43. if (xpp != null) { 
    44. 
  
  
  
  
  44. // 祖父节点设置为红色 
    45. 
  
  
  
  
  45. xpp.red = true; 
    46. 
  
  
  
  
  46. // 以祖父节点为支点右旋 
    47. 
  
  
  
  
  47. root = rotateRight(root, xpp); 
    48. 
  
  
  
  
  48. } 
    49. 
  
  
  
  
  49. } 
    50. 
  
  
  
  
  50. } 
    51. 
  
  
  
  
  51. } 
    52. 
  
  
  
  
  52. // 父节点是祖父节点的右子节点 
    53. 
  
  
  
  
  53. else { 
    54. 
  
  
  
  
  54. // 步骤③：当前节点的父节点是红色，且叔叔节点也是红色 
    55. 
  
  
  
  
  55. if (xppl != null && xppl.red) { 
    56. 
  
  
  
  
  56. // 1.叔叔节点设置为黑色 
    57. 
  
  
  
  
  57. xppl.red = false; 
    58. 
  
  
  
  
  58. // 2.父节点设置为黑色 
    59. 
  
  
  
  
  59. xp.red = false; 
    60. 
  
  
  
  
  60. // 3.祖父节点设置为红色 
    61. 
  
  
  
  
  61. xpp.red = true; 
    62. 
  
  
  
  
  62. // 4.将当前节点指向祖父节点，从新的当前节点重新开始算法 
    63. 
  
  
  
  
  63. x = xpp; 
    64. 
  
  
  
  
  64. } 
    65. 
  
  
  
  
  65. else { 
    66. 
  
  
  
  
  66. // 步骤④：当前节点的父节点是红色，且叔叔节点是黑色，当前节点是其父左子节点 
    67. 
  
  
  
  
  67. if (x == xp.left) { 
    68. 
  
  
  
  
  68. // 当前节点的父节点作为新的当前节点，以新当节点为支点右旋 
    69. 
  
  
  
  
  69. root = rotateRight(root, x = xp); 
    70. 
  
  
  
  
  70. // 重新赋值 
    71. 
  
  
  
  
  71. xpp = (xp = x.parent) == null ? null : xp.parent; 
    72. 
  
  
  
  
  72. } 
    73. 
  
  
  
  
  73. if (xp != null) { 
    74. 
  
  
  
  
  74. // 父节点设置为黑色 
    75. 
  
  
  
  
  75. xp.red = false; 
    76. 
  
  
  
  
  76. if (xpp != null) { 
    77. 
  
  
  
  
  77. // 祖父节点设置为红色 
    78. 
  
  
  
  
  78. xpp.red = true; 
    79. 
  
  
  
  
  79. // 以祖父节点为支点左旋 
    80. 
  
  
  
  
  80. root = rotateLeft(root, xpp); 
    81. 
  
  
  
  
  81. } 
    82. 
  
  
  
  
  82. } 
    83. 
  
  
  
  
  83. } 
    84. 
  
  
  
  
  84. } 
    85. 
  
  
  
  
  85. } 
    86. 
  
  
  
  
  86. } 
    87.

10. 红黑树的删除

红黑树的删除相比插入更加复杂，需要先从链表结构上进行删除，也就是处理当前节点的 next 指针与 prev 指针。如果当前树的节点太少，那么就将树退化为链表。然后，查找被删除节点的后继节点。所谓后继节点，就是当删除节点p后，如果p有子节点，p的子节点上移继承其位置。当找到后继节点，立即删除节点，如果被删除节点是红色，那么不需要平衡，否则平衡红黑树。

红黑树的删除方法代码如下：

 
 
 
 
    
  
  
  
  
  1. final void removeTreeNode(HashMap map, Node[] tab, 
    2. 
  
  
  
  
  2. boolean movable) { 
    3. 
  
  
  
  
  3. int n; 
    4. 
  
  
  
  
  4. if (tab == null || (n = tab.length) == 0)
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. // 不处理空的哈希表
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. return;
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. // 第 1 部分: 处理链表结构 
    11. 
  
  
  
  
  11. // 通过被删除的key的哈希值查找桶(红黑树)的位置
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. int index = (n - 1) & hash; 
    14. 
  
  
  
  
  14. // first、root: 红黑树的根节点 
    15. 
  
  
  
  
  15. TreeNode first = (TreeNode)tab[index], root = first, rl;
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. // succ: 当前节点(被删除节点)的下一个节点
    18. 
  
  
  
  
  18. 
  
  
  
  
  19. // pred: 当前节点(被删除节点)的上一个节点 
    20. 
  
  
  
  
  20. TreeNode succ = (TreeNode)next, pred = prev;
    21. 
  
  
  
  
  21. 
  
  
  
  
  22. // 步骤①：从链表结构上删除当前节点(处理上一个节点的 next 指针与下一个节点的 prev 指针)
    23. 
  
  
  
  
  23. 
  
  
  
  
  24. if (pred == null) 
    25. 
  
  
  
  
  25. // 上一个节点为空，说明是要删除的是根节点，将红黑树的根节点索引改为当前节点的下一个节点 
    26. 
  
  
  
  
  26. tab[index] = first = succ; 
    27. 
  
  
  
  
  27. else 
    28. 
  
  
  
  
  28. // 删除的不是根节点，就把当前节点的上一个节点的next指向当前节点的下一个节点
    29. 
  
  
  
  
  29. pred.next = succ;
    30. 
  
  
  
  
  30. 
  
  
  
  
  31. if (succ != null) 
    32. 
  
  
  
  
  32. // 当前节点的下一个节点不为空，就把下一个节点的prev指向当前节点的上一个节点 
    33. 
  
  
  
  
  33. succ.prev = pred;
    34. 
  
  
  
  
  34. 
  
  
  
  
  35. // 步骤②：删除节点完毕后，红黑树为空，直接返回
    36. 
  
  
  
  
  36. 
  
  
  
  
  37. if (first == null) 
    38. 
  
  
  
  
  38. return;
    39. 
  
  
  
  
  39. 
  
  
  
  
  40. // 步骤③：更新root指针，并判断是否需要将树转为链表结构
    41. 
  
  
  
  
  41. 
  
  
  
  
  42. if (root.parent != null) 
    43. 
  
  
  
  
  43. root = root.root(); 
    44. 
  
  
  
  
  44. if (root == null || root.right == null || 
    45. 
  
  
  
  
  45. (rl = root.left) == null || rl.left == null) { 
    46. 
  
  
  
  
  46. tab[index] = first.untreeify(map); // too small 
    47. 
  
  
  
  
  47. return;
    48. 
  
  
  
  
  48. 
  
  
  
  
  49. }
    50. 
  
  
  
  
  50. 
  
  
  
  
  51. // 第 2 部分: 处理树结构 
    52. 
  
  
  
  
  52. // p: 被删除的节点; replacement: 后继节点(删除节点p后，如果p有子节点，p的子节点上移继承其位置) 
    53. 
  
  
  
  
  53. // pl: 被删除节点的左儿子; pr: 被删除节点的右儿子
    54. 
  
  
  
  
  54. 
  
  
  
  
  55. TreeNode p = this, pl = left, pr = right, replacement;
    56. 
  
  
  
  
  56. 
  
  
  
  
  57. // 步骤①：查找被删除节点的后继节点，分以下几种情况 
    58. 
  
  
  
  
  58. // ⑴ 被删除节点有左子树和右子树
    59. 
  
  
  
  
  59. 
  
  
  
  
  60. if (pl != null && pr != null) { 
    61. 
  
  
  
  
  61. TreeNode s = pr, sl;
    62. 
  
  
  
  
  62. 
  
  
  
  
  63. // 1.查找右子树最左叶子节点s与待删除节点p进行位置互换 
    64. 
  
  
  
  
  64. while ((sl = s.left) != null) // find successor 
    65. 
  
  
  
  
  65. s = sl; 
    66. 
  
  
  
  
  66. // 2.交换最左叶子节点和待删除节点的颜色 
    67. 
  
  
  
  
  67. boolean c = s.red; s.red = p.red; p.red = c; // swap colors 
    68. 
  
  
  
  
  68. // sr：最左叶子节点的右儿子 
    69. 
  
  
  
  
  69. TreeNode sr = s.right; 
    70. 
  
  
  
  
  70. // pp：被删除节点的父节点 
    71. 
  
  
  
  
  71. TreeNode pp = p.parent;
    72. 
  
  
  
  
  72. // 3.交换被删除节点p和最左叶子节点s的位置 
    73. 
  
  
  
  
  73. // 判断最左叶子节点是否是被删除节点的右儿子(即右子树是否只有一个节点)分别处理节点s.right和p.parent的引用 
    74. 
  
  
  
  
  74. if (s == pr) { // p was s's direct parent 
    75. 
  
  
  
  
  75. p.parent = s; 
    76. 
  
  
  
  
  76. s.right = p; 
    77. 
  
  
  
  
  77. } 
    78. 
  
  
  
  
  78. else { 
    79. 
  
  
  
  
  79. TreeNode sp = s.parent; 
    80. 
  
  
  
  
  80. if ((p.parent = sp) != null) { 
    81. 
  
  
  
  
  81. if (s == sp.left) 
    82. 
  
  
  
  
  82. sp.left = p; 
    83. 
  
  
  
  
  83. else 
    84. 
  
  
  
  
  84. sp.right = p; 
    85. 
  
  
  
  
  85. } 
    86. 
  
  
  
  
  86. if ((s.right = pr) != null) 
    87. 
  
  
  
  
  87. pr.parent = s; 
    88. 
  
  
  
  
  88. } 
    89. 
  
  
  
  
  89. p.left = null;
    90. 
  
  
  
  
  90. // 处理p.right和sr.parent的引用 
    91. 
  
  
  
  
  91. if ((p.right = sr) != null) 
    92. 
  
  
  
  
  92. sr.parent = p; 
    93. 
  
  
  
  
  93. // 处理s.left和pl.parent的引用 
    94. 
  
  
  
  
  94. if ((s.left = pl) != null) 
    95. 
  
  
  
  
  95. pl.parent = s; 
    96. 
  
  
  
  
  96. // 处理s.parent的引用和pp.left或pp.right 
    97. 
  
  
  
  
  97. if ((s.parent = pp) == null) 
    98. 
  
  
  
  
  98. root = s; 
    99. 
  
  
  
  
  99. else if (p == pp.left) 
    100. 
  
  
  
  
  100. pp.left = s; 
    101. 
  
  
  
  
  101. else 
    102. 
  
  
  
  
  102. pp.right = s;
    103. 
  
  
  
  
  103. 
  
  
  
  
  104. // 4.交换最左叶子节点和被删除节点的位置完成 
    105. 
  
  
  
  
  105. // 此时被删除节点p在原最左叶子节点的位置，现在被删除节点p没有左子树，如果有右子树，那么右儿子sr就是后继节点，否则后继节点指向自身
    106. 
  
  
  
  
  106. 
  
  
  
  
  107. if (sr != null) 
    108. 
  
  
  
  
  108. replacement = sr; 
    109. 
  
  
  
  
  109. else 
    110. 
  
  
  
  
  110. replacement = p; 
    111. 
  
  
  
  
  111. } 
    112. 
  
  
  
  
  112. // ⑵ 被删除节点只有左子树，后继节点就是左儿子
    113. 
  
  
  
  
  113. 
  
  
  
  
  114. else if (pl != null) 
    115. 
  
  
  
  
  115. replacement = pl; 
    116. 
  
  
  
  
  116. // ⑶ 被删除节点只有右子树，后继节点就是右儿子 
    117. 
  
  
  
  
  117. else if (pr != null) 
    118. 
  
  
  
  
  118. replacement = pr; 
    119. 
  
  
  
  
  119. // ⑷ 被删除节点没有子树，那么后继节点就指向自身 
    120. 
  
  
  
  
  120. else 
    121. 
  
  
  
  
  121. replacement = p; 
    122. 
  
  
  
  
  122. // 步骤②：已经找到删除节点后的后继节点，这一步将从树中彻底删除节点p。
    123. 
  
  
  
  
  123. 
  
  
  
  
  124. if (replacement != p) { 
    125. 
  
  
  
  
  125. // 1.修改替代节点的父节点引用 
    126. 
  
  
  
  
  126. TreeNode pp = replacement.parent = p.parent;
    127. 
  
  
  
  
  127. 
  
  
  
  
  128. // 2.将被删除节点的父节点对其的引用进行修改 
    129. 
  
  
  
  
  129. if (pp == null) 
    130. 
  
  
  
  
  130. root = replacement; 
    131. 
  
  
  
  
  131. else if (p == pp.left) 
    132. 
  
  
  
  
  132. pp.left = replacement; 
    133. 
  
  
  
  
  133. else 
    134. 
  
  
  
  
  134. pp.right = replacement; 
    135. 
  
  
  
  
  135. // 3.彻底删除节点p 
    136. 
  
  
  
  
  136. p.left = p.right = p.parent = null; 
    137. 
  
  
  
  
  137. } 
    138. 
  
  
  
  
  138. // 步骤③：删除节点完成，删除的是红色节点，不需要平衡;否则，平衡 
    139. 
  
  
  
  
  139. TreeNode r = p.red ? root : balanceDeletion(root, replacement); 
    140. 
  
  
  
  
  140. // 步骤④：若没有后继节点，直接删除节点p 
    141. 
  
  
  
  
  141. if (replacement == p) { // detach 
    142. 
  
  
  
  
  142. TreeNode pp = p.parent; 
    143. 
  
  
  
  
  143. p.parent = null; 
    144. 
  
  
  
  
  144. if (pp != null) {
    145. 
  
  
  
  
  145. 
  
  
  
  
  146. if (p == pp.left) 
    147. 
  
  
  
  
  147. pp.left = null; 
    148. 
  
  
  
  
  148. else if (p == pp.right) 
    149. 
  
  
  
  
  149. pp.right = null; 
    150. 
  
  
  
  
  150. } 
    151. 
  
  
  
  
  151. } 
    152. 
  
  
  
  
  152. if (movable) 
    153. 
  
  
  
  
  153. // 确保节点r是树根 
    154. 
  
  
  
  
  154. moveRootToFront(tab, r); 
    155. 
  
  
  
  
  155. } 
    156.

删除红黑树节点之后的平衡代码如下，笔者认为，应当重点关注红黑树的变色、旋转逻辑。

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2. * 平衡红黑树-当删除后 
    3. 
  
  
  
  
  3. * x: 影响平衡的点(俗称：当前节点) 
    4. 
  
  
  
  
  4. */
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. static TreeNode balanceDeletion(TreeNode root, 
    7. 
  
  
  
  
  7. TreeNode x) {
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. // xp: 当前节点的父节点
    10. 
  
  
  
  
  10. 
  
  
  
  
  11. // xpl: 当前节点的父节点的左儿子
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. // xpr: 当前节点的父节点的右儿子
    14. 
  
  
  
  
  14. 
  
  
  
  
  15. for (TreeNode xp, xpl, xpr;;) {
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. // 步骤①：当前节点是null或者是根节点，不改变红黑树的结构，不需要改变
    18. 
  
  
  
  
  18. 
  
  
  
  
  19. if (x == null || x == root)
    20. 
  
  
  
  
  20. 
  
  
  
  
  21. return root;
    22. 
  
  
  
  
  22. 
  
  
  
  
  23. // 步骤②：当前节点成为根节点，置为黑色
    24. 
  
  
  
  
  24. 
  
  
  
  
  25. else if ((xp = x.parent) == null) {
    26. 
  
  
  
  
  26. 
  
  
  
  
  27. x.red = false;
    28. 
  
  
  
  
  28. 
  
  
  
  
  29. return x;
    30. 
  
  
  
  
  30. 
  
  
  
  
  31. }
    32. 
  
  
  
  
  32. 
  
  
  
  
  33. // 步骤③：当前节点为红色，改为黑色后，不影响路径上黑色的数量，不需要改变
    34. 
  
  
  
  
  34. 
  
  
  
  
  35. else if (x.red) {
    36. 
  
  
  
  
  36. 
  
  
  
  
  37. x.red = false;
    38. 
  
  
  
  
  38. 
  
  
  
  
  39. return root;
    40. 
  
  
  
  
  40. 
  
  
  
  
  41. }
    42. 
  
  
  
  
  42. 
  
  
  
  
  43. // 步骤④：当前节点为父节点的左儿子
    44. 
  
  
  
  
  44. 
  
  
  
  
  45. else if ((xpl = xp.left) == x) {
    46. 
  
  
  
  
  46. 
  
  
  
  
  47. // 如果兄弟节点是红色，那么父节点一定是黑色
    48. 
  
  
  
  
  48. 
  
  
  
  
  49. if ((xpr = xp.right) != null && xpr.red) {
    50. 
  
  
  
  
  50. 
  
  
  
  
  51. // 1.兄弟节点置为黑色
    52. 
  
  
  
  
  52. 
  
  
  
  
  53. xpr.red = false;
    54. 
  
  
  
  
  54. 
  
  
  
  
  55. // 2.父节点置为红色
    56. 
  
  
  
  
  56. 
  
  
  
  
  57. xp.red = true;
    58. 
  
  
  
  
  58. 
  
  
  
  
  59. // 3.以父节点为支点左旋 
    60. 
  
  
  
  
  60. root = rotateLeft(root, xp);
    61. 
  
  
  
  
  61. 
  
  
  
  
  62. // 4.刷新兄弟节点 
    63. 
  
  
  
  
  63. xpr = (xp = x.parent) == null ? null : xp.right;
    64. 
  
  
  
  
  64. 
  
  
  
  
  65. }
    66. 
  
  
  
  
  66. 
  
  
  
  
  67. // 如果兄弟节点为空，将当前节点向上调整为父节点，继续循环
    68. 
  
  
  
  
  68. 
  
  
  
  
  69. if (xpr == null)
    70. 
  
  
  
  
  70. 
  
  
  
  
  71. x = xp;
    72. 
  
  
  
  
  72. 
  
  
  
  
  73. else {
    74. 
  
  
  
  
  74. 
  
  
  
  
  75. // sl: 兄弟节点的左儿子 
    76. 
  
  
  
  
  76. // sr: 兄弟节点的右儿子 
    77. 
  
  
  
  
  77. TreeNode sl = xpr.left, sr = xpr.right; 
    78. 
  
  
  
  
  78. if ((sr == null || !sr.red) && 
    79. 
  
  
  
  
  79. (sl == null || !sl.red)) { 
    80. 
  
  
  
  
  80. // 如果兄弟节点没有红色孩子，则兄弟节点置为红色 
    81. 
  
  
  
  
  81. xpr.red = true; 
    82. 
  
  
  
  
  82. // 本轮结束，将当前节点向上调整为父节点，继续循环 
    83. 
  
  
  
  
  83. x = xp;
    84. 
  
  
  
  
  84. 
  
  
  
  
  85. }
    86. 
  
  
  
  
  86. 
  
  
  
  
  87. else {
    88. 
  
  
  
  
  88. 
  
  
  
  
  89. if (sr == null || !sr.red) { 
    90. 
  
  
  
  
  90. // 如果兄弟节点的左儿子是红色就改为黑色 
    91. 
  
  
  
  
  91. if (sl != null) 
    92. 
  
  
  
  
  92. sl.red = false; 
    93. 
  
  
  
  
  93. // 并将兄弟节点置为红色 
    94. 
  
  
  
  
  94. xpr.red = true; 
    95. 
  
  
  
  
  95. // 以兄弟节点为支点右旋 
    96. 
  
  
  
  
  96. root = rotateRight(root, xpr); 
    97. 
  
  
  
  
  97. // 刷新兄弟节点 
    98. 
  
  
  
  
  98. xpr = (xp = x.parent) == null ? 
    99. 
  
  
  
  
  99. null : xp.right; 
    100. 
  
  
  
  
  100. }
    101. 
  
  
  
  
  101. 
  
  
  
  
  102. if (xpr != null) { 
    103. 
  
  
  
  
  103. // 将兄弟节点的颜色染成和父节点一样 
    104. 
  
  
  
  
  104. xpr.red = (xp == null) ? false : xp.red;
    105. 
  
  
  
  
  105. 
  
  
  
  
  106. // 将兄弟节点的右儿子染成黑色，防止出现两个红色节点相连 
    107. 
  
  
  
  
  107. if ((sr = xpr.right) != null) 
    108. 
  
  
  
  
  108. sr.red = false; 
    109. 
  
  
  
  
  109. }
    110. 
  
  
  
  
  110. 
  
  
  
  
  111. if (xp != null) { 
    112. 
  
  
  
  
  112. // 父节点置为黑色，并对其左旋，这样就能保证被删除的节点所在的路径又多了一个黑色节点，从而达到恢复平衡的目的 
    113. 
  
  
  
  
  113. xp.red = false; 
    114. 
  
  
  
  
  114. root = rotateLeft(root, xp); 
    115. 
  
  
  
  
  115. }
    116. 
  
  
  
  
  116. 
  
  
  
  
  117. // 调整完毕，下一次循环直接退出 
    118. 
  
  
  
  
  118. x = root; 
    119. 
  
  
  
  
  119. } 
    120. 
  
  
  
  
  120. } 
    121. 
  
  
  
  
  121. }
    122. 
  
  
  
  
  122. 
  
  
  
  
  123. // 步骤⑤：当前节点为父节点的右儿子，同上
    124. 
  
  
  
  
  124. 
  
  
  
  
  125. else { // symmetric 
    126. 
  
  
  
  
  126. if (xpl != null && xpl.red) { 
    127. 
  
  
  
  
  127. xpl.red = false; 
    128. 
  
  
  
  
  128. xp.red = true; 
    129. 
  
  
  
  
  129. root = rotateRight(root, xp); 
    130. 
  
  
  
  
  130. xpl = (xp = x.parent) == null ? null : xp.left; 
    131. 
  
  
  
  
  131. }
    132. 
  
  
  
  
  132. 
  
  
  
  
  133. if (xpl == null) 
    134. 
  
  
  
  
  134. x = xp;
    135. 
  
  
  
  
  135. 
  
  
  
  
  136. else { 
    137. 
  
  
  
  
  137. TreeNode sl = xpl.left, sr = xpl.right; 
    138. 
  
  
  
  
  138. if ((sl == null || !sl.red) &&
    139. 
  
  
  
  
  139. 
  
  
  
  
  140. (sr == null || !sr.red)) { 
    141. 
  
  
  
  
  141. xpl.red = true; 
    142. 
  
  
  
  
  142. x = xp;
    143. 
  
  
  
  
  143. 
  
  
  
  
  144. }
    145. 
  
  
  
  
  145. 
  
  
  
  
  146. else { 
    147. 
  
  
  
  
  147. if (sl == null || !sl.red) { 
    148. 
  
  
  
  
  148. if (sr != null) 
    149. 
  
  
  
  
  149. sr.red = false; 
    150. 
  
  
  
  
  150. xpl.red = true; 
    151. 
  
  
  
  
  151. root = rotateLeft(root, xpl); 
    152. 
  
  
  
  
  152. xpl = (xp = x.parent) == null ? 
    153. 
  
  
  
  
  153. null : xp.left;
    154. 
  
  
  
  
  154. 
  
  
  
  
  155. }
    156. 
  
  
  
  
  156. 
  
  
  
  
  157.             
    
                分享文章：逐行解读HashMap源码之红黑树篇
                
    
                本文网址：http://www.hantingmc.com/qtweb/news30/344630.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

网页设计公司知识

同城分类信息

微商城开发　　 　网站营销　　 　成都装饰装修　　 　温江做网站　　 　移动手机网站制作　　 　公路打桩机　　 　注册域名　　 　网站seo　　 　温江做网站　　 　成都小程序开发　　 　域名注册　　 　百度关键词排名　　 　四川电信高防服务器托管　　 　成都花箱　　 　眉山托管服务器　　 　中晴建设　　 　泸县网站建设　　 　四川主机托管　　 　金羊影视传媒　　 　新型地坪材料