JDK集合源码之解析TreeMap(二)

删除元素

删除元素本身比较简单，就是采用二叉树的删除规则。

• 如果删除的位置有两个叶子节点，则从其右子树中取最小的元素放到删除的位置，然后把删除位置移到替代元素的位置，进入下一步。
• 如果删除的位置只有一个叶子节点（有可能是经过第一步转换后的删除位置），则把那个叶子节点作为替代元素，放到删除的位置，然后把这个叶子节点删除。
• 如果删除的位置没有叶子节点，则直接把这个删除位置的元素删除即可。
• 针对红黑树，如果删除位置是黑色节点，还需要做再平衡。
• 如果有替代元素，则以替代元素作为当前节点进入再平衡。
• 如果没有替代元素，则以删除的位置的元素作为当前节点进入再平衡，平衡之后再删除这个节点。

1. public V remove(Object key) {
2. // 获取节点
3. Entry<K,V> p = getEntry(key);
4. if (p == null)
5. return null;
6. V oldValue = p.value;
7. // 删除节点
8. deleteEntry(p);
9. // 返回删除的value
10. return oldValue;
11. }
12. private void deleteEntry(Entry<K,V> p) {
13. // 修改次数加1
14. modCount++;
15. // 元素个数减1
16. size--;
17. if (p.left != null && p.right != null) {
18. // 如果当前节点既有左子节点，又有右子节点
19. // 取其右子树中最小的节点
20. Entry<K,V> s = successor(p);
21. // 用右子树中最小节点的值替换当前节点的值
22. p.key = s.key;
23. p.value = s.value;
24. // 把右子树中最小节点设为当前节点
25. p = s;
26. // 这种情况实际上并没有删除p节点，而是把p节点的值改了，实际删除的是p的后继节点
27. }
28. // 如果原来的当前节点（p）有2个子节点，则当前节点已经变成原来p的右子树中的最小节点了，也就是说其没有左子节点了
29. // 到这一步，p肯定只有一个子节点了
30. // 如果当前节点有子节点，则用子节点替换当前节点
31. Entry<K,V> replacement = (p.left != null ? p.left : p.right);
32. if (replacement != null) {
33. // 把替换节点直接放到当前节点的位置上（相当于删除了p，并把替换节点移动过来了）
34. replacement.parent = p.parent;
35. if (p.parent == null)
36. root = replacement;
37. else if (p == p.parent.left)
38. p.parent.left = replacement;
39. else
40. p.parent.right = replacement;
41. // 将p的各项属性都设为空
42. p.left = p.right = p.parent = null;
43. // 如果p是黑节点，则需要再平衡
44. if (p.color == BLACK)
45. fixAfterDeletion(replacement);
46. } else if (p.parent == null) {
47. // 如果当前节点就是根节点，则直接将根节点设为空即可
48. root = null;
49. } else {
50. // 如果当前节点没有子节点且其为黑节点，则把自己当作虚拟的替换节点进行再平衡
51. if (p.color == BLACK)
52. fixAfterDeletion(p);
53. // 平衡完成后删除当前节点（与父节点断绝关系）
54. if (p.parent != null) {
55. if (p == p.parent.left)
56. p.parent.left = null;
57. else if (p == p.parent.right)
58. p.parent.right = null;
59. p.parent = null;
60. }
61. }
62. }

删除再平衡

经过上面的处理，真正删除的肯定是黑色节点才会进入到再平衡阶段。

因为删除的是黑色节点，导致整颗树不平衡了，所以这里我们假设把删除的黑色赋予当前节点，这样当前节点除了它自已的颜色还多了一个黑色，那么：

（1）如果当前节点是根节点，则直接涂黑即可，不需要再平衡；

（2）如果当前节点是红+黑节点，则直接涂黑即可，不需要平衡；

（3）如果当前节点是黑+黑节点，则我们只要通过旋转把这个多出来的黑色不断的向上传递到一个红色节点即可，这又可能会出现以下四种情况：

（假设当前节点为父节点的左子节点）

（假设当前节点为父节点的右子节点，正好反过来）

让我们来看看TreeMap中的实现：

1. /**
2. * 删除再平衡
3. *（1）每个节点或者是黑色，或者是红色。
4. *（2）根节点是黑色。
5. *（3）每个叶子节点（NIL）是黑色。（注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！）
6. *（4）如果一个节点是红色的，则它的子节点必须是黑色的。
7. *（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
8. */
9. private void fixAfterDeletion(Entry<K,V> x) {
10. // 只有当前节点不是根节点且当前节点是黑色时才进入循环
11. while (x != root && colorOf(x) == BLACK) {
12. if (x == leftOf(parentOf(x))) {
13. // 如果当前节点是其父节点的左子节点
14. // sib是当前节点的兄弟节点
15. Entry<K,V> sib = rightOf(parentOf(x));
16. // 情况1）如果兄弟节点是红色
17. if (colorOf(sib) == RED) {
18. // （1）将兄弟节点设为黑色
19. setColor(sib, BLACK);
20. // （2）将父节点设为红色
21. setColor(parentOf(x), RED);
22. // （3）以父节点为支点进行左旋
23. rotateLeft(parentOf(x));
24. // （4）重新设置x的兄弟节点，进入下一步
25. sib = rightOf(parentOf(x));
26. }
27. if (colorOf(leftOf(sib)) == BLACK &&
28. colorOf(rightOf(sib)) == BLACK) {
29. // 情况2）如果兄弟节点的两个子节点都是黑色
30. // （1）将兄弟节点设置为红色
31. setColor(sib, RED);
32. // （2）将x的父节点作为新的当前节点，进入下一次循环
33. x = parentOf(x);
34. } else {
35. if (colorOf(rightOf(sib)) == BLACK) {
36. // 情况3）如果兄弟节点的右子节点为黑色
37. // （1）将兄弟节点的左子节点设为黑色
38. setColor(leftOf(sib), BLACK);
39. // （2）将兄弟节点设为红色
40. setColor(sib, RED);
41. // （3）以兄弟节点为支点进行右旋
42. rotateRight(sib);
43. // （4）重新设置x的兄弟节点
44. sib = rightOf(parentOf(x));
45. }
46. // 情况4）
47. // （1）将兄弟节点的颜色设为父节点的颜色
48. setColor(sib, colorOf(parentOf(x)));
49. // （2）将父节点设为黑色
50. setColor(parentOf(x), BLACK);
51. // （3）将兄弟节点的右子节点设为黑色
52. setColor(rightOf(sib), BLACK);
53. // （4）以父节点为支点进行左旋
54. rotateLeft(parentOf(x));
55. // （5）将root作为新的当前节点（退出循环）
56. x = root;
57. }
58. } else { // symmetric
59. // 如果当前节点是其父节点的右子节点
60. // sib是当前节点的兄弟节点
61. Entry<K,V> sib = leftOf(parentOf(x));
62. // 情况1）如果兄弟节点是红色
63. if (colorOf(sib) == RED) {
64. // （1）将兄弟节点设为黑色
65. setColor(sib, BLACK);
66. // （2）将父节点设为红色
67. setColor(parentOf(x), RED);
68. // （3）以父节点为支点进行右旋
69. rotateRight(parentOf(x));
70. // （4）重新设置x的兄弟节点
71. sib = leftOf(parentOf(x));
72. }
73. if (colorOf(rightOf(sib)) == BLACK &&
74. colorOf(leftOf(sib)) == BLACK) {
75. // 情况2）如果兄弟节点的两个子节点都是黑色
76. // （1）将兄弟节点设置为红色
77. setColor(sib, RED);
78. // （2）将x的父节点作为新的当前节点，进入下一次循环
79. x = parentOf(x);
80. } else {
81. if (colorOf(leftOf(sib)) == BLACK) {
82. // 情况3）如果兄弟节点的左子节点为黑色
83. // （1）将兄弟节点的右子节点设为黑色
84. setColor(rightOf(sib), BLACK);
85. // （2）将兄弟节点设为红色
86. setColor(sib, RED);
87. // （3）以兄弟节点为支点进行左旋
88. rotateLeft(sib);
89. // （4）重新设置x的兄弟节点
90. sib = leftOf(parentOf(x));
91. }
92. // 情况4）
93. // （1）将兄弟节点的颜色设为父节点的颜色
94. setColor(sib, colorOf(parentOf(x)));
95. // （2）将父节点设为黑色
96. setColor(parentOf(x), BLACK);
97. // （3）将兄弟节点的左子节点设为黑色
98. setColor(leftOf(sib), BLACK);
99. // （4）以父节点为支点进行右旋
100. rotateRight(parentOf(x));
101. // （5）将root作为新的当前节点（退出循环）
102. x = root;
103. }
104. }
105. }
106. // 退出条件为多出来的黑色向上传递到了根节点或者红节点
107. // 则将x设为黑色即可满足红黑树规则
108. setColor(x, BLACK);
109. }

删除元素举例

假设我们有下面这样一颗红黑树。

我们删除6号元素，则从右子树中找到了最小元素7，7又没有子节点了，所以把7作为当前节点进行再平衡。

我们看到7是黑节点，且其兄弟为黑节点，且其兄弟的两个子节点都是红色，满足情况4），平衡之后如下图所示。

我们再删除7号元素，则从右子树中找到了最小元素8，8有子节点且为黑色，所以8的子节点9是替代节点，以9为当前节点进行再平衡。

我们发现9是红节点，则直接把它涂成黑色即满足了红黑树的特性，不需要再过多的平衡了。

这次我们来个狠的，把根节点删除，从右子树中找到了最小的元素5，5没有子节点，所以把5作为当前节点进行再平衡。

我们看到5是黑节点，且其兄弟为红色，符合情况1），平衡之后如下图所示，然后进入情况2）。

对情况2）进行再平衡后如下图所示。

然后进入下一次循环，发现不符合循环条件了，直接把x涂为黑色即可，退出这个方法之后会把旧x删除掉（见deleteEntry()方法），最后的结果就是下面这样。

二叉树的遍历

我们知道二叉查找树的遍历有前序遍历、中序遍历、后序遍历。

（1）前序遍历，先遍历我，再遍历我的左子节点，最后遍历我的右子节点；

（2）中序遍历，先遍历我的左子节点，再遍历我，最后遍历我的右子节点；

（3）后序遍历，先遍历我的左子节点，再遍历我的右子节点，最后遍历我；

这里的前中后都是以“我”的顺序为准的，我在前就是前序遍历，我在中就是中序遍历，我在后就是后序遍历。

下面让我们看看经典的中序遍历是怎么实现的：

1. public class TreeMapTest {
2. public static void main(String[] args) {
3. // 构建一颗10个元素的树
4. TreeNode<Integer> node = new TreeNode<>(1, null).insert(2)
5. .insert(6).insert(3).insert(5).insert(9)
6. .insert(7).insert(8).insert(4).insert(10);
7. // 中序遍历，打印结果为1到10的顺序
8. node.root().inOrderTraverse();
9. }
10. }
11. /**
12. * 树节点，假设不存在重复元素
13. * @param <T>
14. */
15. class TreeNode<T extends Comparable<T>> {
16. T value;
17. TreeNode<T> parent;
18. TreeNode<T> left, right;
19. public TreeNode(T value, TreeNode<T> parent) {
20. this.value = value;
21. this.parent = parent;
22. }
23. /**
24. * 获取根节点
25. */
26. TreeNode<T> root() {
27. TreeNode<T> cur = this;
28. while (cur.parent != null) {
29. cur = cur.parent;
30. }
31. return cur;
32. }
33. /**
34. * 中序遍历
35. */
36. void inOrderTraverse() {
37. if(this.left != null) this.left.inOrderTraverse();
38. System.out.println(this.value);
39. if(this.right != null) this.right.inOrderTraverse();
40. }
41. /**
42. * 经典的二叉树插入元素的方法
43. */
44. TreeNode<T> insert(T value) {
45. // 先找根元素
46. TreeNode<T> cur = root();
47. TreeNode<T> p;
48. int dir;
49. // 寻找元素应该插入的位置
50. do {
51. p = cur;
52. if ((dir=value.compareTo(p.value)) < 0) {
53. cur = cur.left;
54. } else {
55. cur = cur.right;
56. }
57. } while (cur != null);
58. // 把元素放到找到的位置
59. if (dir < 0) {
60. p.left = new TreeNode<>(value, p);
61. return p.left;
62. } else {
63. p.right = new TreeNode<>(value, p);
64. return p.right;
65. }
66. }
67. }

TreeMap的遍历

从上面二叉树的遍历我们很明显地看到，它是通过递归的方式实现的，但是递归会占用额外的空间，直接到线程栈整个释放掉才会把方法中申请的变量销毁掉，所以当元素特别多的时候是一件很危险的事。

（上面的例子中，没有申请额外的空间，如果有声明变量，则可以理解为直到方法完成才会销毁变量）

那么，有没有什么方法不用递归呢？

让我们来看看java中的实现：

1. @Override
2. public void forEach(BiConsumer<? super K, ? super V> action) {
3. Objects.requireNonNull(action);
4. // 遍历前的修改次数
5. int expectedModCount = modCount;
6. // 执行遍历，先获取第一个元素的位置，再循环遍历后继节点
7. for (Entry<K, V> e = getFirstEntry(); e != null; e = successor(e)) {
8. // 执行动作
9. action.accept(e.key, e.value);
10. // 如果发现修改次数变了，则抛出异常
11. if (expectedModCount != modCount) {
12. throw new ConcurrentModificationException();
13. }
14. }
15. }

是不是很简单？！

（1）寻找第一个节点；

从根节点开始找最左边的节点，即最小的元素。

1. final Entry<K,V> getFirstEntry() {
2. Entry<K,V> p = root;
3. // 从根节点开始找最左边的节点，即最小的元素
4. if (p != null)
5. while (p.left != null)
6. p = p.left;
7. return p;
8. }

（2）循环遍历后继节点；

寻找后继节点这个方法我们在删除元素的时候也用到过，当时的场景是有右子树，则从其右子树中寻找最小的节点。

1. static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
2. if (t == null)
3. // 如果当前节点为空，返回空
4. return null;
5. else if (t.right != null) {
6. // 如果当前节点有右子树，取右子树中最小的节点
7. Entry<K,V> p = t.right;
8. while (p.left != null)
9. p = p.left;
10. return p;
11. } else {
12. // 如果当前节点没有右子树
13. // 如果当前节点是父节点的左子节点，直接返回父节点
14. // 如果当前节点是父节点的右子节点，一直往上找，直到找到一个祖先节点是其父节点的左子节点为止，返回这个祖先节点的父节点
15. Entry<K,V> p = t.parent;
16. Entry<K,V> ch = t;
17. while (p != null && ch == p.right) {
18. ch = p;
19. p = p.parent;
20. }
21. return p;
22. }
23. }

让我们一起来分析下这种方式的时间复杂度吧。

首先，寻找第一个元素，因为红黑树是接近平衡的二叉树，所以找最小的节点，相当于是从顶到底了，时间复杂度为O(log n)；

其次，寻找后继节点，因为红黑树插入元素的时候会自动平衡，最坏的情况就是寻找右子树中最小的节点，时间复杂度为O(log k)，k为右子树元素个数；

最后，需要遍历所有元素，时间复杂度为O(n)；

所以，总的时间复杂度为 O(log n) + O(n * log k) ≈ O(n)。

虽然遍历红黑树的时间复杂度是O(n)，但是它实际是要比跳表要慢一点的，啥？跳表是啥？安心，后面会讲到跳表的。

总结

到这里红黑树就整个讲完了，让我们再回顾下红黑树的特性：

• 每个节点或者是黑色，或者是红色。
• 根节点是黑色。
• 每个叶子节点（NIL）是黑色。（注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！）
• 如果一个节点是红色的，则它的子节点必须是黑色的。
• 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

除了上述这些标准的红黑树的特性，你还能讲出来哪些TreeMap的特性呢？

• TreeMap的存储结构只有一颗红黑树；
• TreeMap中的元素是有序的，按key的顺序排列；
• TreeMap比HashMap要慢一些，因为HashMap前面还做了一层桶，寻找元素要快很多；
• TreeMap没有扩容的概念；
• TreeMap的遍历不是采用传统的递归式遍历；
• TreeMap可以按范围查找元素，查找最近的元素；

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

原文链接：https://csp1999.blog.csdn.net/article/details/112514930