TreeMap使用红黑树进行存储，可以按照键值的大小进行排序(自然排序或者是自定义排序)
1. 继承体系
- 继承了AbstractMap，而AbstractMap实现了Map接口中的一些方法，因此减少了TreeMap实现Map接口的复杂度
- 实现了Map接口，具备了Map框架，其中存储的元素是键值对
- 实现了NavigableMap接口，意味着元素具有极强的元素搜索能力
- 实现了Cloneable接口，具备克隆能力
- 实现了Serializable接口，可以被序列化和反序列化
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable
对于AbstractMap、Map、Cloneable、Serializable接口，我们都不陌生，而对于NavigableMap接口，我们从没有见过，那么我们来看看它的源码吧
首先我们可以看出NavigableMap接口，继承于SortedMap接口，对于SortedMap接口，里面定义了比较器，决定了排序的走向
public interface SortedMap<K,V> extends Map<K,V> {
//比较器，如果是自然排序（从小到大），则返回null
Comparator<? super K> comparator();
//返回从fromKey到toKey的集合，[fromKey, toKey)
SortedMap<K,V> subMap(K fromKey, K toKey);
//返回从头到toKey的集合，不包含toKey，[head, toKey)
SortedMap<K,V> headMap(K toKey);
//返回从fromKey到结尾的集合，包含fromKey，[fromKey, tail]
SortedMap<K,V> tailMap(K fromKey);
//返回集合中的第一个元素
K firstKey();
//返回集合中的最后一个元素
K lastKey();
//返回集合中所有key的集合
Set<K> keySet();
//返回集合中所有value的集合
Collection<V> values();
//返回集合中所有键值对的映射
Set<Map.Entry<K, V>> entrySet();
}
介绍了SortedMap接口，我们接下来来看看NavigableMap接口，NavigableMap接口是对SortedMap接口功能的扩展，主要增加了对集合内元素的搜索获取功能，例如，返回区间内小于等于key的第一个元素是谁等方法
public interface NavigableMap<K,V> extends SortedMap<K,V> {
//返回小于key的第一个key对应的键值对
Map.Entry<K,V> lowerEntry(K key);
//返回小于key的第一个key
K lowerKey(K key);
//返回小于等于key的第一个key对应的键值对
Map.Entry<K,V> floorEntry(K key);
//返回小于等于key的第一个key
K floorKey(K key);
//返回大于等于key的第一个key对应的键值对
Map.Entry<K,V> ceilingEntry(K key);
//返回大于等于key的第一个key
K ceilingKey(K key);
//返回大于key的第一个key对应的键值对
Map.Entry<K,V> higherEntry(K key);
//返回大于key的第一个key
K higherKey(K key);
//返回集合中第一个键值对
Map.Entry<K,V> firstEntry();
//返回集合中最后一个键值对
Map.Entry<K,V> lastEntry();
//返回集合中第一个键值对，并从集合中删除
Map.Entry<K,V> pollFirstEntry();
//返回结合中最后一个键值对，并从集合中删除
Map.Entry<K,V> pollLastEntry();
//返回倒序的键值对集合
NavigableMap<K,V> descendingMap();
//返回有序的key集合
NavigableSet<K> navigableKeySet();
//返回集合中倒序的键集合
NavigableSet<K> descendingKeySet();
//返回从fromKey到toKey的子集合，是否包含边界可以自己决定
NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
K toKey, boolean toInclusive);
//返回小于toKey的子集合，是否包含toKey可以自己决定
NavigableMap<K,V> headMap(K toKey, boolean inclusive);
//返回大于fromKey的子集合，是否包含fromKey可以自己决定
NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
//等价于 subMap(fromKey, true, toKey, false);
SortedMap<K,V> subMap(K fromKey, K toKey);
//等价于headMap(toKey, false);
SortedMap<K,V> headMap(K toKey);
//等价于tailMap(fromKey, true);
SortedMap<K,V> tailMap(K fromKey);
}
TreeMap底层是基于红黑树存储的（下面是红黑树的一张图）
2. 红黑树
那么红黑树是什么呢？
红黑树是带有color属性的二叉查找树，color 的值为红色或黑色，因此叫做红黑树。
下面是二叉查找树的定义:
二叉查找树（BST：Binary Search Tree）是一种特殊的二叉树，它改善了二叉树节点查找的效率。二叉查找树有以下性质：
（1）若左子树不空，则左子树上所有节点的值均小于它的根节点的值
（2）若右子树不空，则右子树上所有节点的值均大于它的根节点的值
（3）左、右子树也分别为二叉查找树
（4）没有键值相等的节点
红黑树在满足二叉搜索树的基础上还要满足5个性质：
- 每个节点必须有颜色，要么是红色，要么是黑色
- 根节点必须是黑色
- 树中的叶子节点必须是黑的，也就是树尾的null节点
- 如果一个节点是红色的，那么它的子节点必须是黑色的
- 任一结点到叶子结点所经过的路径上所包含的黑色节点数目一定相同
下面我们来了解一下红黑树的基本操作，比如旋转（调节高度问题）
旋转
左旋
顾名思义，就是对某个节点进行向左旋转
动图：
对节点X进行坐旋转，就是将X变成一个左子结点，其中，如果Y的左子结点不为空，就将Y的左子结点变成X的右子节点
右旋
顾名思义，就是对一个节点进行向右旋转
动图：
对Y进行右旋，就是将Y变成一个右子节点，如果X有右子节点，就将X的右子节点变成Y的左子节点
添加
对红黑树进行添加，就是插入到一个叶子结点，这只需要遍历就可以找到应该放在哪个位置了，对于红黑树而言，每一个节点都有颜色，我们是将添加的结点染成红色还是黑色的呢？
我们再来回顾一下红黑树的性质：
- 每个节点必须有颜色，要么是红色，要么是黑色
- 根节点必须是黑色
- 树中的叶子节点必须是黑的，也就是树尾的null节点
- 如果一个节点是红色的，那么它的子节点必须是黑色的
- 任一结点到叶子结点所经过的路径上所包含的黑色节点数目一定相同
如果我们将添加的结点染成红色
对于第一条，一定不会违背
对于第二条，可能会违背，但是如果为根节点我们最后一定会把它染成黑色，所以不考虑这个，这里看成不违背
对于第三条，不违背
对于第四条，可能违背
对于第五条，不违背
如果我们将添加的结点染成黑色
对于第一条，一定不会违背
对于第二条，不违背
对于第三条，不违背
对于第四条，可能违背
对于第五条，一定违背
本着方便的原则，染成红色违背的条数最少，所以我们将新添加的节点染成红色
当我们插入一个节点并将其染成红色时，可能会违背红黑树的性质，这个时候我们就需要进行一些操作来使红黑树满足它的性质
下面我们来分一下情况：
-
当被插入的节点是第一个结点，也就是根节点
以为刚开始插入的时候被染成了红色，而红黑树的根节点是黑色的，所以我们将它染成红色即可满足红黑树的所有性质
-
当被插入节点的父节点是黑色的话，并不会违背红黑树的任何性质，因此这种情况不必进行任何操作
-
当被插入节点的父节点是红色的话
-
叔叔节点是黑色（空节点默认是黑色）
这种情况又分为四种情况：
其中，A、B称为外侧插入，C、D称为内侧插入
首先，我们来看A的解决方案
将3染成黑色，5染成红色，对5进行右旋
接下来是B的解决方案
将16染成黑色，15染成红色，对15进行左旋
接下来是C的解决方案
对15进行左旋，称为17的左子结点，就变成了A情况，接下来将17染成黑色，23染成红色，对23进行右旋
最后是D的解决方案
首先对46进行右旋，使46称为43的右子节点，变成了B情况，将43染成黑色，41染成红色，对41进行左旋
-
叔叔节点是红色
当叔叔节点为红色时，处理逻辑比较简单，只需要重新进行染色即可，无序左旋、右旋操作
下面是对应于A的情况，无论新插入的节点是7或12
对于B的情况也是一样
-
删除
当我们想要删除一个结点时，首先需要遍历找到这个结点，接下来我们分为三种情况：
- 被删除节点无子节点，直接删除即可（不会违反红黑树的性质）
- 被删除节点只有（左子树或右子树），直接删除并用子节点替代
- 被删除节点有两个子节点，找到被删除节点的后继节点（中序遍历紧跟在后面的第一个节点，即大于当前节点的第一个节点），把后继节点的值赋给被删除节点，后继节点才是我们真正需要删除的节点，该后继节点要么没有子节点，要么只有右子节点，之后转而进行该后继节点的删除，也就进入到了情况1或情况2。
我们可以看出，对于情况1直接删除即可，对于情况3，情况3也会进入到情况1或情况2，情况1比较简单，因此，我们的主要任务就是对于情况2的分析（情况2比较复杂）
首先，对于情况2，如果被删除节点是红色的，直接删除并用子节点代替即可，不涉及旋转问题
但如果被删除节点是黑色的，就会涉及到旋转问题，我们将删除节点（以下五种情况被删除节点都是D）是黑色的情况分为以下五种：
-
兄弟节点为红色
被删除的节点是D，解决方案是将B（兄弟节点）染为黑色，父节点染为红色，对父节点进行左旋，进入到情况4。
-
兄弟节点为黑色，远侄节点为红色
被删除节点是D，解决方案是将父节点和兄弟接地交换颜色，将远侄节点染成黑色，对父节点进行左旋操作，调整结束。
-
兄弟节点为黑色，近侄节点为红色
删除节点是D，将兄弟节点染为红色，近侄节点染为黑色，对兄弟节点进行右旋，进入到情况2。
-
父节点为红色，兄弟节点为黑色，该兄弟节点的子节点都为黑色（无子节点）
删除节点是D，将父节点染成黑色，兄弟节点染成红色，调整结束。
-
父节点为黑色，兄弟节点为黑色，该兄弟节点的子节点都为黑色（无子节点）
将兄弟节点染红（这样当前节点在删除后该子树和兄弟子树的每条路径黑色节点数一样，但是对于祖父来说是符合的），对父节点进行调整作进入下一次循环。
3. 源码解析
属性
TreeMap中元素是以键值对形式进行存储的
//K的比较器
private final Comparator<? super K> comparator;
//根节点
private transient Entry<K,V> root;
//元素数量
private transient int size = 0;
//修改次数
private transient int modCount = 0;
内部类，元素存储形式
典型的红黑树存储形式
static final class Entry<K,V> implements Map.Entry<K,V> {
K key; //键
V value; //值
Entry<K,V> left; //左子节点
Entry<K,V> right; //右子节点
Entry<K,V> parent; //父节点
boolean color = BLACK; //颜色
//构造函数
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
//返回key
public K getKey() {
return key;
}
//返回值
public V getValue() {
return value;
}
//设置值
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
//重写equals方法
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
}
//重写hashcode方法
public int hashCode() {
int keyHash = (key==null ? 0 : key.hashCode());
int valueHash = (value==null ? 0 : value.hashCode());
return keyHash ^ valueHash;
}
//重写toString方法
public String toString() {
return key + "=" + value;
}
}
补充：key的排序方式有两种
- 实现Comparable接口，重写compareTo方法
- 实现Comparator接口，重写compare方法
构造方法
//默认构造方法
public TreeMap() {
comparator = null;
}
//传入指定Comparator排序方式
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
//传入Map集合，把传入集合中所有元素保存到TreeMap中
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
//传入比较器，并把传入集合中所有元素保存到TreeMap中
public TreeMap(SortedMap<K, ? extends V> m) {
comparator = m.comparator();
try {
buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
}
成员方法
get(Object key)
public V get(Object key) {
//由key查找键值对
Entry<K,V> p = getEntry(key);
//找到了返回对应的值，没找到返回null
return (p==null ? null : p.value);
}
final Entry<K,V> getEntry(Object key) {
// Offload comparator-based version for sake of performance
if (comparator != null)
return getEntryUsingComparator(key); //使用Comparator比较器
//不使用Comparator比较器
if (key == null)
throw new NullPointerException();
//使用Comparable接口进行比较
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
Entry<K,V> p = root; //从根开始寻找
while (p != null) {
int cmp = k.compareTo(p.key);
if (cmp < 0)
p = p.left; //在左子树查找
else if (cmp > 0)
p = p.right; //在右子树查找
else
return p; //找到
}
return null;
}
final Entry<K,V> getEntryUsingComparator(Object key) {
@SuppressWarnings("unchecked")
K k = (K) key;
Comparator<? super K> cpr = comparator;
if (cpr != null) {
Entry<K,V> p = root; //从根开始寻找
while (p != null) {
int cmp = cpr.compare(k, p.key);
if (cmp < 0)
p = p.left; //在左子树查找
else if (cmp > 0)
p = p.right; //在右子树查找
else
return p;
}
}
return null;
}
步骤：
- 从根开始遍历树
- 比当前节点的key小，在左子树找
- 比当前节点的key大，在右子树找
- 当前节点的key和要找节点的key相等，返回当前节点
rotateLeft（Entry<K,V> p）
左旋操作
过程如下：
（1）将 y的左节点 设为 x 的右节点，即将 β 设为 x的右节点；
（2）将 x 设为 y的左节点的父节点，即将 β的父节点 设为 x；
（3）将 x的父节点 设为 y 的父节点；
（4）如果 x的父节点 为空节点，则将y设置为根节点；如果x是它父节点的左（右）节点，则将y设置为x父节点的左（右）节点；
（5）将 x 设为 y的左节点；
（6）将 x的父节点 设为 y；
//p就是节点X
private void rotateLeft(Entry<K,V> p) {
if (p != null) {
//p的右节点
Entry<K,V> r = p.right;
//（1）将Y的左节点设为X的右节点
p.right = r.left;
//（2）将X设为Y的左节点的父节点
if (r.left != null)
r.left.parent = p;
//（3）将X的父节点设为Y的父节点
r.parent = p.parent;
//（4）······
if (p.parent == null)
//X的父节点为空，设Y为根
root = r;
//X是父节点的左节点，将Y设为X的父节点的左节点
else if (p.parent.left == p)
p.parent.left = r;
//X是父节点的右节点，将Y设为X的父节点的右节点
else
p.parent.right = r;
//（5）将X设为Y结点的左节点
r.left = p;
//（6）将X的父节点设为Y
p.parent = r;
}
}
rotateRight(Entry<K,V> p)
右旋操作
过程如下：
（1）将 x的右节点 设为 y的左节点，即 将 β 设为 y的左节点；
（2）将 y 设为 x的右节点的父节点，即 将 β的父节点 设为 y；
（3）将 y的父节点 设为 x的父节点；
（4）如果 y的父节点 是 空节点，则将x设为根节点；如果y是它父节点的左（右）节点，则将x设为y的父节点的左（右）节点；
（5）将 y 设为 x的右节点；
（6）将 y的父节点 设为 x；
//右旋操作
//p就是Y结点
private void rotateRight(Entry<K,V> p) {
if (p != null) {
//l是X节点
Entry<K,V> l = p.left;
//（1）将X的右节点设为Y的左节点
p.left = l.right;
//（2）将Y设为X的右节点的父节点
if (l.right != null) l.right.parent = p;
//（3）将Y的父节点设为X的父节点
l.parent = p.parent;
//（4）·····
if (p.parent == null)
//Y的父节点是空节点，将X设为根节点
root = l;
else if (p.parent.right == p)
//Y是它父节点的右节点，将X设为Y的父节点的右节点
p.parent.right = l;
//Y是它父节点的左节点，将X设为Y的父节点的左节点
else p.parent.left = l;
//（5）将Y设为X的右节点
l.right = p;
//（6）将X设为Y的父节点
p.parent = l;
}
}
put(K key, V value)
**插入元素**，如果key在树中**存在**，则**覆盖**value，如果key在树中**不存在**，则**创建**对应节点，再平衡树
public V put(K key, V value) {
Entry<K,V> t = root;
//无根节点，直接插入到根节点
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1; //元素个数
modCount++; //修改次数
return null; //返回null
}
int cmp;
Entry<K,V> parent; //父节点
// split comparator and comparable paths
Comparator<? super K> cpr = comparator; //比较器
//利用比较器比较
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left; //在左子树寻找
else if (cmp > 0)
t = t.right; //在右子树寻找
else
return t.setValue(value); //已经找到，覆盖value并返回
} while (t != null);
}
//利用接口方式比较
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left; //在左子树寻找
else if (cmp > 0)
t = t.right; //在右子树寻找
else
return t.setValue(value); //已经找到，覆盖value并返回
} while (t != null);
}
//没找到
Entry<K,V> e = new Entry<>(key, value, parent); //创建结点
if (cmp < 0)
parent.left = e; //作为当前节点的左子节点
else
parent.right = e; //作为当前节点的右子节点
//插入之后的平衡
fixAfterInsertion(e);
//元素数量加1
size++;
//修改次数加1
modCount++;
//返回null
return null;
}
fixAfterInsertion(Entry<K,V> x)
插入再平衡
（如果父节点是祖父节点的左节点）
| 情况 | 策略 |
|---|---|
| 1）父节点为红色，叔叔节点也为红色 | （1）将父节点设为黑色； （2）将叔叔节点设为黑色； （3）将祖父节点设为红色； （4）将祖父节点设为新的当前节点，进入下一次循环判断； |
| 2）父节点为红色，叔叔节点为黑色，且当前节点是其父节点的右节点 | （1）将父节点作为新的当前节点； （2）以新当节点为支点进行左旋，进入情况3； |
| 3）父节点为红色，叔叔节点为黑色，且当前节点是其父节点的左节点 | （1）将父节点设为黑色； （2）将祖父节点设为红色； （3）以祖父节点为支点进行右旋，进入下一次循环判断； |
（如果父节点是祖父节点的右节点，则正好与上面反过来）
| 情况 | 策略 |
|---|---|
| 1）父节点为红色，叔叔节点也为红色 | （1）将父节点设为黑色； （2）将叔叔节点设为黑色； （3）将祖父节点设为红色； （4）将祖父节点设为新的当前节点，进入下一次循环判断； |
| 2）父节点为红色，叔叔节点为黑色，且当前节点是其父节点的左节点 | （1）将父节点作为新的当前节点； （2）以新当节点为支点进行右旋，进入情况3； |
| 3）父节点为红色，叔叔节点为黑色，且当前节点是其父节点的右节点 | （1）将父节点设为黑色； （2）将祖父节点设为红色； （3）以祖父节点为支点进行左旋，进入下一次循环判断； |
private void fixAfterInsertion(Entry<K,V> x) {
//当前节点为红色
x.color = RED;
//当x不为null且x不是根节点且x的父节点的颜色是红色
//只有当三个条件都满足时树不满足红黑树的性质，当三个条件只要有一个条件不满足时，该树都满足红黑树的性质，既不需要平衡
while (x != null && x != root && x.parent.color == RED) {
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
//如果父节点是祖父节点的左节点，y为叔叔节点
Entry<K,V> y = rightOf(parentOf(parentOf(x)));
//如果叔叔节点为红色
if (colorOf(y) == RED) {
//（1）将父节点设为黑色
setColor(parentOf(x), BLACK);
//（2）将叔叔节点设为黑色
setColor(y, BLACK);
//（3）将祖父节点设为红色
setColor(parentOf(parentOf(x)), RED);
//（4）将祖父节点设为当前新的节点，进入下一次循环判断
x = parentOf(parentOf(x));
} else {
//叔叔节点为黑色
//情况2：当前节点是父节点的右节点
if (x == rightOf(parentOf(x))) {
//（1）将父节点设为当前节点
x = parentOf(x);
//（2）以新的当前节点进行左旋
rotateLeft(x);
}
//情况3
//（1）将父节点设为黑色
setColor(parentOf(x), BLACK);
//（2）将祖父节点设为红色
setColor(parentOf(parentOf(x)), RED);
//（3）以祖父节点为支点进行右旋，进入下一次循环判断
rotateRight(parentOf(parentOf(x)));
}
} else {
//如果父节点是祖父节点的右节点
//y是叔叔节点
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
if (colorOf(y) == RED) {
//情况1：叔叔节点为红色
//（1）将父节点设为黑色
setColor(parentOf(x), BLACK);
//（2）将叔叔节点设为黑色
setColor(y, BLACK);
//（3）将祖父节点设为红色
setColor(parentOf(parentOf(x)), RED);
//（4）将祖父节点设为新的当前节点，进入下一次循环判断
x = parentOf(parentOf(x));
} else {
//情况2：叔叔结点为黑色，当前节点是父节点的左节点
if (x == leftOf(parentOf(x))) {
//（1）将父节点作为新的当前节点
x = parentOf(x);
//（2）以新的当前节点进行右旋，进入情况3
rotateRight(x);
}
//情况3：当前节点是父节点的右节点
//（1）将父节点设为黑色
setColor(parentOf(x), BLACK);
//（2）将祖父节点设为红色
setColor(parentOf(parentOf(x)), RED);
//（3）以祖父节点为支点进行左旋，进入下一次循环判断
rotateLeft(parentOf(parentOf(x)));
}
}
}
//平衡完成后将根节点设为黑色
root.color = BLACK;
}
remove(Object key)
删除节点
public V remove(Object key) {
Entry<K,V> p = getEntry(key); //找到对应的键值对
if (p == null)
return null;
V oldValue = p.value;
deleteEntry(p); //删除键值对
return oldValue;
}
deleteEntry(Entry<K,V> p)
删除键值对
private void deleteEntry(Entry<K,V> p) {
modCount++; //修改次数加1
size--; //元素数量
if (p.left != null && p.right != null) {
//如果当前结点既有多子节点又有右子节点，寻找该节点右子树的最小节点
Entry<K,V> s = successor(p);
//将当前节点的值设为右子树最小节点的值，改为删除右子树最小值的节点
p.key = s.key;
p.value = s.value;
p = s;
}
//如果当前节点有子节点，用子节点的值替换当前节点
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
//把替换节点放到当前节点的位置上
if (replacement != null) {
replacement.parent = p.parent;
if (p.parent == null)
root = replacement;
else if (p == p.parent.left)
p.parent.left = replacement;
else
p.parent.right = replacement;
//将p的各属性都设为空
p.left = p.right = p.parent = null;
//如果p颜色为黑色，则需要再平衡
if (p.color == BLACK)
fixAfterDeletion(replacement);
} else if (p.parent == null) {
//如果当前节点是根节点，将根节点置空
root = null;
} else {
if (p.color == BLACK)
//当前节点为黑色且无子节点，平衡该节点
fixAfterDeletion(p);
if (p.parent != null) {
//父节点不为空，如果当前节点是父节点的左节点，将父节点的左节点置空，如果当前节点是父节点的右节点，将父节点的右节点置空
if (p == p.parent.left)
p.parent.left = null;
else if (p == p.parent.right)
p.parent.right = null;
p.parent = null;
}
}
}
fixAfterDeletion(Entry<K,V> x)
删除再平衡
（假设当前节点为父节点的左子节点）
| 情况 | 策略 |
|---|---|
| 1）x是黑+黑节点，x的兄弟是红节点 | （1）将兄弟节点设为黑色； （2）将父节点设为红色； （3）以父节点为支点进行左旋； （4）重新设置x的兄弟节点，进入下一步； |
| 2）x是黑+黑节点，x的兄弟是黑节点，且兄弟节点的两个子节点都是黑色 | （1）将兄弟节点设置为红色； （2）将x的父节点作为新的当前节点，进入下一次循环； |
| 3）x是黑+黑节点，x的兄弟是黑节点，且兄弟节点的右子节点为黑色，左子节点为红色 | （1）将兄弟节点的左子节点设为黑色； （2）将兄弟节点设为红色； （3）以兄弟节点为支点进行右旋； （4）重新设置x的兄弟节点，进入下一步； |
| 4）x是黑+黑节点，x的兄弟是黑节点，且兄弟节点的右子节点为红色，左子节点任意颜色 | （1）将兄弟节点的颜色设为父节点的颜色； （2）将父节点设为黑色； （3）将兄弟节点的右子节点设为黑色； （4）以父节点为支点进行左旋； （5）将root作为新的当前节点（退出循环）； |
（假设当前节点为父节点的右子节点，正好反过来）
| 情况 | 策略 |
|---|---|
| 1）x是黑+黑节点，x的兄弟是红节点 | （1）将兄弟节点设为黑色； （2）将父节点设为红色； （3）以父节点为支点进行右旋； （4）重新设置x的兄弟节点，进入下一步； |
| 2）x是黑+黑节点，x的兄弟是黑节点，且兄弟节点的两个子节点都是黑色 | （1）将兄弟节点设置为红色； （2）将x的父节点作为新的当前节点，进入下一次循环； |
| 3）x是黑+黑节点，x的兄弟是黑节点，且兄弟节点的左子节点为黑色，右子节点为红色 | （1）将兄弟节点的右子节点设为黑色； （2）将兄弟节点设为红色； （3）以兄弟节点为支点进行左旋； （4）重新设置x的兄弟节点，进入下一步； |
| 4）x是黑+黑节点，x的兄弟是黑节点，且兄弟节点的左子节点为红色，右子节点任意颜色 | （1）将兄弟节点的颜色设为父节点的颜色； （2）将父节点设为黑色； （3）将兄弟节点的左子节点设为黑色； （4）以父节点为支点进行右旋； （5）将root作为新的当前节点（退出循环）； |
private void fixAfterDeletion(Entry<K,V> x) {
//只有当当前节点不是根节点且当前节点是黑色的才进入循环进行平衡
while (x != root && colorOf(x) == BLACK) {
if (x == leftOf(parentOf(x))) {
//当前节点是其父节点的左子节点
//sib是当前节点的兄弟节点
Entry<K,V> sib = rightOf(parentOf(x));
//情况1：兄弟节点是红色
if (colorOf(sib) == RED) {
//（1）将兄弟节点设为红色
setColor(sib, BLACK);
//（2）将父节点设为红色
setColor(parentOf(x), RED);
//（3）以父节点为支点进行左旋
rotateLeft(parentOf(x));
//（4）重新设置x的兄弟节点，进行下一部
sib = rightOf(parentOf(x));
}
//情况2：兄弟节点是黑色节点，且兄弟节点的两个子节点都是黑色
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {
//（1）将兄弟节点设置为红色
setColor(sib, RED);
//（2）将x的父节点作为新的当前节点，进入下一次循环
x = parentOf(x);
} else {
//情况3：兄弟节点的右节点为黑色
if (colorOf(rightOf(sib)) == BLACK) {
//（1）将兄弟节点的左子节点设为黑色
setColor(leftOf(sib), BLACK);
//（2）将兄弟节点设为红色
setColor(sib, RED);
//（3）以兄弟节点为支点进行右旋
rotateRight(sib);
//（4）重新设置x的兄弟节点，进入下一步
sib = rightOf(parentOf(x));
}
//情况4：
//（1）将兄弟节点的颜色设置为父节点的颜色
setColor(sib, colorOf(parentOf(x)));
//（2）将父节点设为黑色
setColor(parentOf(x), BLACK);
//（3）将兄弟节点的右子节点设为黑色
setColor(rightOf(sib), BLACK);
//（4）以父节点为支点进行左旋
rotateLeft(parentOf(x));
//（5）将root作为当前节点并退出循环
x = root;
}
} else { // symmetric
//当前节点是父节点的右子节点
//sib是兄弟节点
Entry<K,V> sib = leftOf(parentOf(x));
//情况1：兄弟节点是红色
if (colorOf(sib) == RED) {
//（1）将兄弟节点设为黑色
setColor(sib, BLACK);
//（2）将父节点化为红色
setColor(parentOf(x), RED);
//（3）以父节点为支点进行右旋
rotateRight(parentOf(x));
//（4）重新设置x的兄弟节点，进入下一步
sib = leftOf(parentOf(x));
}
if (colorOf(rightOf(sib)) == BLACK &&
colorOf(leftOf(sib)) == BLACK) {
//情况2：兄弟节点的两个子节点都是黑色
//（1）将兄弟节点设置为红色
setColor(sib, RED);
//（2）将x的父节点作为新的当前节点，进入下一次循环
x = parentOf(x);
} else {
//情况3：兄弟节点的左子节点是黑色
if (colorOf(leftOf(sib)) == BLACK) {
//（1）将兄弟节点的右子节点设为黑色
setColor(rightOf(sib), BLACK);
//（2）将兄弟节点设为红色
setColor(sib, RED);
//（3）以兄弟节点为支点进行左旋
rotateLeft(sib);
//（4）重新设置x的兄弟节点，进入下一步
sib = leftOf(parentOf(x));
}
//情况4：
//（1）将兄弟节点的颜色设置为父节点的颜色
setColor(sib, colorOf(parentOf(x)));
//（2）将父节点设置为黑色
setColor(parentOf(x), BLACK);
//（3）将兄弟节点的左子节点设置为黑色
setColor(leftOf(sib), BLACK);
//（4）以父节点为支点进行右旋
rotateRight(parentOf(x));
//（5）将root作为新的当前节点并退出
x = root;
}
}
}
setColor(x, BLACK);
}
4. 总结
- TreeMap的存储结构只有一棵树
- TreeMap中的元素是有序的，按key的顺序排列
- TreeMap比HashMap要慢一些，因为HashM前面还做了一些桶
- TreeMap没有扩容的概念
- TreeMap可以按范围查找元素，查找最近的元素
文章学习于：
https://www.jianshu.com/p/2dcff3634326
https://zhuanlan.zhihu.com/p/74673007
http://blog.ztgreat.cn/article/12
https://csp1999.blog.csdn.net/article/details/112514930
215
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
