一、前言
在前一篇博客中，我們對TreeMap的繼承關系進行了分析，在這一篇里，我們將分析TreeMap的數據結構，深入理解它的排序能力是如何實現的。這一節要有一定的數據結構基礎，在閱讀下面的之前，推薦大家先看一下：《算法4》深入理解紅黑樹。（個人比較喜歡算法四這里介紹的紅黑樹實現：從2-3樹到紅黑樹的過渡很清晰，雖然源碼里的實現不是這種方式 T^T），先了解一下紅黑樹的由來以及它的特性，這樣能更好的理解TreeMap的實現。
二、 TreeMap的結構
TreeMap的內部實現就是一個紅黑樹。
對於紅黑樹的定義：
- 節點是紅色或黑色。
- 根是黑色。
- 所有葉子都是黑色（葉子是NIL節點）。
- 每個紅色節點必須有兩個黑色的子節點。（從每個葉子到根的所有路徑上不能有兩個連續的紅色節點。）
- 從任一節點到其每個葉子的所有簡單路徑都包含相同數目的黑色節點。
三、Tree源碼解析
在前一篇博客中，我們已經見過了TreeMap的繼承關系，所以這里就不重復了，讓我們來看一下它的其他內容。
3.1 TreeMap的成員變量
public class TreeMap<K,V> extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.Serializable {
// Key的比較器，用作排序
private final Comparator<? super K> comparator;
//樹的根節點
private transient Entry<K,V> root;
//樹的大小
private transient int size = 0;
//修改計數器
private transient int modCount = 0;
//返回map的Entry視圖
private transient EntrySet entrySet;
private transient KeySet<K> navigableKeySet;
private transient NavigableMap<K,V> descendingMap;
//定義紅黑樹的顏色
private static final boolean RED = false;
private static final boolean BLACK = true;
}
3.2 TreeMap的構造方法
對一些不重要的構造方法就不流水賬一樣的記錄了。
3.2.1 TreeMap(Comparator<? super K> comparator)
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
允許用戶自定義比較器進行key的排序。
3.2.2 public TreeMap(Map<? extends K, ? extends V> m)
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
public void putAll(Map<? extends K, ? extends V> map) {
int mapSize = map.size();
//判斷map是否SortedMap，不是則采用AbstractMap的putAll
if (size==0 && mapSize!=0 && map instanceof SortedMap) {
Comparator<?> c = ((SortedMap<?,?>)map).comparator();
//同為null或者不為null，類型相同，則進入有序map的構造
if (c == comparator || (c != null && c.equals(comparator))) {
++modCount;
try {
buildFromSorted(mapSize, map.entrySet().iterator(),
null, null);
} catch (java.io.IOException cannotHappen) {
} catch (ClassNotFoundException cannotHappen) {
}
return;
}
}
super.putAll(map);
}
buildFromSorted將在后面解析，因為后面的構造函數也調用了這個方法。
3.2.3 public TreeMap(SortedMap<K, ? extends V> m)
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) {
}
}
下面讓我們來看一下這個buildFromSorted方法：
/**
* size: map里鍵值對的數量
* it: 傳入的map的entries迭代器
* str: 如果不為空，則從流里讀取key-value
* defaultVal：見名知意，不為空，則value都用這個值
*/
private void buildFromSorted(int size, Iterator<?> it,
java.io.ObjectInputStream str,
V defaultVal)
throws java.io.IOException, ClassNotFoundException {
this.size = size;
root = buildFromSorted(0, 0, size-1, computeRedLevel(size),
it, str, defaultVal);
}
我們先來分析一下computeRedLevel方法：
private static int computeRedLevel(int sz) {
int level = 0;
for (int m = sz - 1; m >= 0; m = m / 2 - 1)
level++;
return level;
}
它的作用是用來計算完全二叉樹的層數。什么意思呢，先來看一下下面的圖：
把根結點索引看為0，那么高度為2的樹的最后一個節點的索引為2，類推高度為3的最后一個節點為6，滿足m = (m + 1) * 2。那么計算這個高度有什么好處呢，如上圖，如果一個樹有9個節點，那么我們構造紅黑樹的時候，只要把前面3層的結點都設置為黑色，第四層的節點設置為紅色，則構造完的樹，就是紅黑樹，滿足前面提到的紅黑樹的5個條件。而實現的關鍵就是找到要構造樹的完全二叉樹的層數。
了解了上面的原理，后面就簡單了，接着來看buildFromSorted方法：
/**
* level: 當前樹的層數，注意：是從0層開始
* lo: 子樹第一個元素的索引
* hi: 子樹最后一個元素的索引
* redLevel: 上述紅節點所在層數
* 剩下的3個就不解釋了，跟上面的一樣
*/
@SuppressWarnings("unchecked")
private final Entry<K,V> buildFromSorted(int level, int lo, int hi,
int redLevel,
Iterator<?> it,
java.io.ObjectInputStream str,
V defaultVal)
throws java.io.IOException, ClassNotFoundException {
// hi >= lo 說明子樹已經構造完成
if (hi < lo) return null;
// 取中間位置，無符號右移，相當於除2
int mid = (lo + hi) >>> 1;
Entry<K,V> left = null;
//遞歸構造左結點
if (lo < mid)
left = buildFromSorted(level+1, lo, mid - 1, redLevel,
it, str, defaultVal);
K key;
V value;
// 通過迭代器獲取key， value
if (it != null) {
if (defaultVal==null) {
Map.Entry<?,?> entry = (Map.Entry<?,?>)it.next();
key = (K)entry.getKey();
value = (V)entry.getValue();
} else {
key = (K)it.next();
value = defaultVal;
}
// 通過流來讀取key, value
} else {
key = (K) str.readObject();
value = (defaultVal != null ? defaultVal : (V) str.readObject());
}
//構建結點
Entry<K,V> middle = new Entry<>(key, value, null);
// level從0開始的，所以上述9個節點，計算出來的是3，實際上就是代表的第4層
if (level == redLevel)
middle.color = RED;
//如果存在的話，設置左結點，
if (left != null) {
middle.left = left;
left.parent = middle;
}
// 遞歸構造右結點
if (mid < hi) {
Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel,
it, str, defaultVal);
middle.right = right;
right.parent = middle;
}
return middle;
}
**另外提一句，buildFromSorted能這么構造是因為這是一個已經排序的map。😃 **
具體的構造順序如下圖（偷懶畫了個簡單的 ）:
感興趣的園友可以自己分析一下上面9個節點的是如何構造的。
3.3 TreeMap的重要方法
接下來，我們來看一下TreeMap里的一些重要的方法。
3.3.1 get(Object key)
對於map來說，根據key來獲取value幾乎是最常見的操作，下面我們來看一下：
public V get(Object key) {
//內部調用了getEntry方法。
Entry<K,V> p = getEntry(key);
return (p==null ? null : p.value);
}
final Entry<K,V> getEntry(Object key) {
// 如果有比較器，則調用通過比較器的來比較key的方法
if (comparator != null)
return getEntryUsingComparator(key);
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
// 獲取key的Comparable接口
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;
}
對於Comparable<? super K> k = (Comparable<? super K>) key;，筆者一開始的時候在想為什么用<? super K>，用<? extends K>不行嗎，不是根據PECS（Producer Extends, Consumer Super）原則，取出來的時候用extends嗎。后來發現太傻了 T^T，這一原則是用來針對list的。這里肯定是用super，用K或者K的父類的compareTo方法。如果用extends的話，K的子類加了其他屬性進行比較，那就根本沒法進行比較了。
至於getEntryUsingComparator方法就不分析了，就是把compareTo變成了用Comparator進行比較，有興趣的園友可以自己看看。
3.3.2 put(K key, V value)
public V put(K key, V value) {
Entry<K,V> t = root;
//根結點為空，則進行添加根結點並初始化參數
if (t == null) {
//用來進行類型檢查
compare(key, key);
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// 與get類型，分離comparator與comparable的比較
Comparator<? super K> cpr = comparator;
if (cpr != null) {
//循環查找key，如果找到則替換value，沒有則記錄其parent，后面進行插入
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);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
//循環查找key，如果找到則替換value，沒有則記錄其parent，后面進行插入
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);
} while (t != null);
}
//創建結點，然后比較與parent的大小，小放在左結點，大放在右節點
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
//對紅黑樹進行修復
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
put的邏輯還是比較清晰的，關鍵在於fixAfterInsertion對插入結點后的紅黑樹進行修復，維護其平衡，我們接着來看看它是如何實現的（在繼續看之前，建議園友們先去了解一下左旋轉和右旋轉的操作）。
private void fixAfterInsertion(Entry<K,V> x) {
//約定插入的結點都是紅節點
x.color = RED;
//x本身紅色，如果其父節點也是紅色，違反規則4，進行循環處理
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)));
//p為左結點，y為紅色 ①
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
// p為左結點，y為黑，x為右節點 ②
if (x == rightOf(parentOf(x))) {
x = parentOf(x);
rotateLeft(x);
}
// p為左結點，y為紅，x為左結點 ③
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
//父節點是右結點
} else {
Entry<K,V> y = leftOf(parentOf(parentOf(x)));
//p為右結點，y為紅色 ④
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
} else {
//p為右結點，y為黑色，x為左結點 ⑤
if (x == leftOf(parentOf(x))) {
x = parentOf(x);
rotateRight(x);
}
//p為右結點，y為黑色，x為右結點 ⑥
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
//約定根結點都是黑節點
root.color = BLACK;
}
總結一下有這么幾種情況：
- 由於p為紅，則x沒有兄弟結點（原則4），要想插入后維持紅黑樹平衡，必須從p，pp以及p的兄弟結點y中找到對應的處理情況來平衡。
- 首先，插入的結點x，顏色肯定是紅色，插入位置兩種情況——左結點或者右結點。
- 其次，父結點p肯定為紅色，因為父節點p為黑色的話，那就不用調整了（插入紅節點對原則五並沒有印象），所以只有父結點p是左結點和右結點的兩種情況。
- 既然父結點p為紅色，那么父父結點pp肯定為黑色（根據原則四），那么p的兄弟節點y，存在兩種情況，顏色為紅或者黑。
所以綜上，x插入要調整的所有情況有：2 * 2 * 2 = 8種，但是當y為紅色的時候不用調整，不需要考慮x的插入位置，所以8 - 2 = 6種，且只要懂三種就夠了，剩余的是左右對稱的。至於為什么要這么處理這里就不展開了。感興趣的園友們可以推薦這篇看一下：紅黑樹的插入操作
至於左旋轉和右旋轉就不拿出來分析了。
3.3.3 remove(Object key)
最后我們再來看一下remove方法：
public V remove(Object key) {
//獲取Entry
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
V oldValue = p.value;
//刪除的關鍵方法
deleteEntry(p);
return oldValue;
}
在看deleteEntry之前，我們先來看一下successor方法，為其做准備：
//查找t的后繼結點
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
if (t == null)
return null;
//從t的右子樹中找到最小的
else if (t.right != null) {
Entry<K,V> p = t.right;
while (p.left != null)
p = p.left;
return p;
//當右子樹為空時，向上找到第一個左父節點
} else {
Entry<K,V> p = t.parent;
Entry<K,V> ch = t;
while (p != null && ch == p.right) {
ch = p;
p = p.parent;
}
return p;
}
}
上述的目的是找到最接近且大於t的結點，這樣的話，直接用來替換掉t，對原有的樹結構變動最小。
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
//① p的左右子樹都不為空，找到右子樹中最小的結點，將key、value賦給p，然后p指向后繼結點
if (p.left != null && p.right != null) {
Entry<K,V> s = successor(p);
p.key = s.key;
p.value = s.value;
p = s;
}
//獲取p中不為空的結點，也可能兩個都是空的
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;
//清空鏈接，以便可以使用fixAfterDeletion和內存回收
p.left = p.right = p.parent = null;
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)
//清空鏈接，方便GC
p.parent.left = null;
else if (p == p.parent.right)
p.parent.right = null;
//清空鏈接，方便GC
p.parent = null;
}
}
}
整體思路是：
- 當刪除結點p的左右結點都不為空的時候，選擇大於且最接近p的后繼結點s，直接將s的key、value替換掉p的原有值，然后對后繼結點s做刪除處理。此時的s必有一個左必為空，做操作2
- 對於有左右結點有一個為空的p時，在不為空的結點replacement，與p的parent之間修改父子節點間引用關系
- 兩個結點都是空的就更簡單了，直接刪掉
- 對於刪除的黑色的結點進行fix
在獲取replacement的時候，p的左右結點為空的個數>=1，
- 沒有進前面if條件，則說明p至少有一個為空
- 進入if條件，則在p的右樹中找最小節點s，s左結點必為空，右結點可能存在
下面讓我們來看一下fixAfterDeletion的源碼的源碼：
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) {
//x是左結點且為黑色
if (x == leftOf(parentOf(x))) {
//獲取兄弟右節點
Entry<K,V> sib = rightOf(parentOf(x));
//① 兄弟右節點sib顏色是紅色
if (colorOf(sib) == RED) {
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x));
}
//② sib的子節點都是黑色
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
//sib子節點不全為黑
} else {
//③ sib右子節點為黑色
if (colorOf(rightOf(sib)) == BLACK) {
setColor(leftOf(sib), BLACK);
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x));
}
// ④
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
}
// 對稱
} else {
Entry<K,V> sib = leftOf(parentOf(x));
if (colorOf(sib) == RED) {
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateRight(parentOf(x));
sib = leftOf(parentOf(x));
}
if (colorOf(rightOf(sib)) == BLACK &&
colorOf(leftOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
} else {
if (colorOf(leftOf(sib)) == BLACK) {
setColor(rightOf(sib), BLACK);
setColor(sib, RED);
rotateLeft(sib);
sib = leftOf(parentOf(x));
}
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(leftOf(sib), BLACK);
rotateRight(parentOf(x));
x = root;
}
}
}
setColor(x, BLACK);
}
fixAfterDeletion總體思路是：由於刪除的結點x是黑色，所以在該結點的樹上做調整沒法使紅黑樹恢復平衡，所以要依靠x的兄弟結點sib做文章，依靠p結點以及sib和其子結點，將x的黑色結點+1，這里具體就不展開了。感興趣的園友們可以推薦這篇看一下：紅黑樹的刪除操作
四、總結
TreeMap這一章對數據結構的理解有一定的要求。如果深入分析為什么在插入和刪除調整過程中做這些操作的話，篇幅會太長，以后如果有空的話，再細細討論。另外有解讀不對的地方可以留言指正，最后謝謝各位園友觀看，與大家共同進步！
參考鏈接：