前言
今天來介紹下TreeMap,TreeMap是基於紅黑樹結構實現的一種Map，要分析TreeMap的實現首先就要對紅黑樹有所瞭解。
構造圖如下:
藍色線條：繼承
綠色線條：接口實現
正文
TreeMap底層是基於紅黑樹（Red-Black tree）實現，所以在學習TreeMap之前我們先來了解下紅黑樹。
紅黑樹又稱紅-黑二叉樹，它首先是一顆二叉樹，它具體二叉樹所有的特性。同時紅黑樹更是一顆自平衡的排序二叉樹。
我們知道一顆基本的二叉樹他們都需要滿足一個基本性質--即樹中的任何節點的值大於它的左子節點，且小於它的右子節點。按照這個基本性質使得樹的檢索效率大大提高。我們知道在生成二叉樹的過程是非常容易失衡的，最壞的情況就是一邊倒（只有右/左子樹），這樣勢必會導致二叉樹的檢索效率大大降低（O(n)），所以爲了維持二叉樹的平衡，大牛們提出了各種實現的算法，如：AVL，SBT，伸展樹，TREAP
，紅黑樹等等。
平衡二叉樹必須具備如下特性：它是一棵空樹或它的左右兩個子樹的高度差的絕對值不超過1，並且左右兩個子樹都是一棵平衡二叉樹。也就是說該二叉樹的任何一個等等子節點，其左右子樹的高度都相近。
紅黑樹顧名思義就是節點是紅色或者黑色的平衡二叉樹，它通過顏色的約束來維持着二叉樹的平衡。對於一棵有效的紅黑樹二叉樹而言我們必須增加如下規則：
- 每個節點都只能是紅色或者黑色
- 根節點是黑色
- 每個葉節點（NIL節點，空節點）是黑色的。
- 如果一個結點是紅的，則它兩個子節點都是黑的。也就是說在一條路徑上不能出現相鄰的兩個紅色結點。
- 從任一節點到其每個葉子的所有路徑都包含相同數目的黑色節點。
紅黑樹示意圖如下：
上面的規則前4條都好理解，第5條規則到底是什麼情況，下面簡單解釋下，比如圖中紅8到1左邊的葉子節點的路徑包含兩個黑色節點，到6下面的葉子節點的路徑也包含兩個黑色節點。
但是在在添加或刪除節點後，紅黑樹就發生了變化，可能不再滿足上面的5個特性，爲了保持紅黑樹的以上特性，就有了三個動作：左旋、右旋、着色。
下面來看下什麼是紅黑樹的左旋和右旋：
對x進行左旋，意味着"將x變成一個左節點"。
對y進行右旋，意味着"將y變成一個右節點"。
如果還是沒看明白，下面找了兩張左旋和右旋的動態圖
ok，對二叉樹、紅黑樹的概念有所瞭解後，我們來看下紅黑樹的兩個主要邏輯添加和刪除，看看TreeMap是怎麼實現的。
TreeMap簡介
TreeMap定義
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, java.io.SerializableTreeMap 是一個有序的key-value集合，它是通過紅黑樹實現的。
TreeMap 繼承於AbstractMap，所以它是一個Map，即一個key-value集合。
TreeMap 實現了NavigableMap接口，意味着它支持一系列的導航方法。比如返回有序的key集合。
TreeMap 實現了Cloneable接口，意味着它能被克隆。
TreeMap 實現了java.io.Serializable接口，意味着它支持序列化。
TreeMap基於紅黑樹（Red-Black tree）實現。該映射根據其鍵的自然順序進行排序，或者根據創建映射時提供的 Comparator 進行排序，具體取決於使用的構造方法。
TreeMap的基本操作 containsKey、get、put 和 remove 的時間複雜度是 log(n) 。
另外，TreeMap是非同步的。 它的iterator 方法返回的迭代器是fail-fast的。
TreeMap屬性
// 比較器
private final Comparator<? super K> comparator;
// 紅黑樹根節點
private transient Entry<K,V> root = null;
// 集合元素數量
private transient int size = 0;
// "fail-fast"集合修改記錄
private transient int modCount = 0;TreeMap的本質是R-B Tree(紅黑樹)，它包含幾個重要的成員變量： root, size, comparator。
- root 是紅黑數的根節點。它是Entry類型，Entry是紅黑數的節點，它包含了紅黑數的6個基本組成成分：key(鍵)、value(值)、left(左孩子)、right(右孩子)、parent(父節點)、color(顏色)。Entry節點根據key進行排序，Entry節點包含的內容爲value。
- 紅黑數排序時，根據Entry中的key進行排序；Entry中的key比較大小是根據比較器comparator來進行判斷的。
- size是紅黑數中節點的個數。
Entry是樹的節點類，我們來看一下Entry的定義：
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
// 左孩子節點
Entry<K,V> left = null;
// 右孩子節點
Entry<K,V> right = null;
// 父節點
Entry<K,V> parent;
// 紅黑樹用來表示節點顏色的屬性，默認爲黑色
boolean color = BLACK;
/**
* 用key，value和父節點構造一個Entry，默認爲黑色
*/
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}
public K getKey() {
return key ;
}
public V getValue() {
return value ;
}
public V setValue(V value) {
V oldValue = this.value ;
this.value = value;
return oldValue;
}
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());
}
public int hashCode() {
int keyHash = (key ==null ? 0 : key.hashCode());
int valueHash = (value ==null ? 0 : value.hashCode());
return keyHash ^ valueHash;
}
public String toString() {
return key + "=" + value;
}
}Entry類理解起來比較簡單（因爲我們前面看過很多的Entry類了），主要是定義了樹的孩子和父親節點引用，和紅黑顏色屬性，並對equals和hashCode進行重寫，以利於比較是否相等。
HashMap構造函數
/**
* 默認構造方法，comparator爲空，代表使用key的自然順序來維持TreeMap的順序，這裏要求key必須實現Comparable接口
*/
public TreeMap() {
comparator = null;
}
/**
* 用指定的比較器構造一個TreeMap
*/
public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}
/**
* 構造一個指定map的TreeMap，同樣比較器comparator爲空，使用key的自然順序排序
*/
public TreeMap(Map<? extends K, ? extends V> m) {
comparator = null;
putAll(m);
}
/**
* 構造一個指定SortedMap的TreeMap，根據SortedMap的比較器來來維持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) {
}
}從構造方法中可以看出，要創建一個紅黑樹實現的TreeMap必須要有一個用於比較大小的比較器，因爲只有能夠比較大小才能實現紅黑樹的左孩子<樹根<右孩子的特點。
API方法摘要
TreeMap源碼解析(基於JDK1.6.0_45)
紅黑樹的添加原理及TreeMap的put實現
將一個節點添加到紅黑樹中，通常需要下面幾個步驟：
- 將紅黑樹當成一顆二叉查找樹，將節點插入.
這一步比較簡單，就上開始我們自己寫的二叉查找樹的操作一樣，至於爲什麼可以這樣插入，是因爲紅黑樹本身就是一個二叉查找樹。 - 將新插入的節點設置爲紅色
有沒有疑問，爲什麼新插入的節點一定要是紅色的，因爲新插入節點爲紅色，不會違背紅黑規則第（5）條，少違背一條就少處理一種情況。 - 通過旋轉和着色，使它恢復平衡，重新變成一顆符合規則的紅黑樹。
要想知道怎麼樣進行左旋和右旋，首先就要知道爲什麼要進行左旋和右旋。
我們來對比下紅黑樹的規則和新插入節點後的情況，看下新插入節點會違背哪些規則。
（1）節點是紅色或黑色。
這一點肯定是不會違背的了。
（2）根節點是黑色。
這一點也不會違背了，如果是根節點，只需將根節點插入就好了，因爲默認是黑色。
（3）每個葉節點（NIL節點，空節點）是黑色的。
這一點也不會違背的，我們插入的是非空的節點，不會影響空節點。
（4）每個紅色節點的兩個子節點都是黑色。(從每個葉子到根的所有路徑上不能有兩個連續的紅色節點)
這一點是有可能違背的，我們將新插入的節點都設置成紅色，如果其父節點也是紅色的話，那就產生衝突了。
（5）從任一節點到其每個葉子的所有路徑都包含相同數目的黑色節點。
這一點也不會違背，因爲我們將新插入的節點都設置成紅色。
瞭解了紅黑樹左旋和右旋操作，以及新插入節點主要是可能會違背紅黑樹的規則（4）後，我們來分析下，添加新節點的過程有哪幾種情況：
（1）新插入節點爲根節點。這種情況直接將新插入節點設置爲根節點即可，無需進行後續的旋轉和着色處理。
（2）新插入節點的父節點是黑色。這種情況直接將新節點插入即可，不會違背規則（4）。
（3）新插入節點的父節點是紅色。這種情況會違背規則（4），而這種情況又分爲了以下幾種，下面進行圖解：
①新插入節點N的父節點P和叔叔節點U都是紅色。方法是：將祖父節點G設置爲紅色，父節點P和叔叔節點U設置爲黑色，這時候就看似平衡了。但是，如果祖父節點G的父節點也是紅色，這時候又違背規則（4）了，怎麼辦，方法是：將GPUN這一組看成一個新的節點，按照前面的方案遞歸；又但是根節點爲紅就違反規則（2）了，怎麼辦，方法是直接將根節點設置爲黑色（兩個連續黑色是沒問題的）。
②新插入節點N的父節點P是紅色，叔叔節點U是黑色或者缺少，且新節點N是P的右孩子。方法是：左旋父節點P。左旋後N和P角色互換，但是P和N還是連續的兩個紅色節點，還沒有平衡，怎麼辦，看第三種情況。
③新插入節點N的父節點P是紅色，叔叔節點U是黑色或者缺少，且新節點N是P的左孩子。方法是：右旋祖父節點G，然後將P設置爲黑色，G設置爲紅色，達到平衡。此時父節點P是黑色，所有不用擔心P的父節點是紅色。
當然上面說的三種情況都是基於一個前提：新插入節點N的父節點P是祖父節點G的左孩子，如果P是G的右孩子又是什麼情況呢？其實情況和上面是相似的，只需要調整左旋還是右旋，這裏就不細講了。
上面分析了這麼多，到底TreeMap是怎麼實現的呢，我們來看下：
public V put(K key, V value) {
// 根節點
Entry<K,V> t = root;
// 如果根節點爲空，則直接創建一個根節點，返回
if (t == null) {
// TBD:
// 5045147: (coll) Adding null to an empty TreeSet should
// throw NullPointerException
//
// compare(key, key); // type check
root = new Entry<K,V>(key, value, null);
size = 1;
modCount++;
return null;
}
// 記錄比較結果
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
// 當前使用的比較器
Comparator<? super K> cpr = comparator ;
// 如果比較器不爲空，就是用指定的比較器來維護TreeMap的元素順序
if (cpr != null) {
// do while循環，查找key要插入的位置（也就是新節點的父節點是誰）
do {
// 記錄上次循環的節點t
parent = t;
// 比較當前節點的key和新插入的key的大小
cmp = cpr.compare(key, t. key);
// 新插入的key小的話，則以當前節點的左孩子節點爲新的比較節點
if (cmp < 0)
t = t. left;
// 新插入的key大的話，則以當前節點的右孩子節點爲新的比較節點
else if (cmp > 0)
t = t. right;
else
// 如果當前節點的key和新插入的key想的的話，則覆蓋map的value，返回
return t.setValue(value);
// 只有當t爲null，也就是沒有要比較節點的時候，代表已經找到新節點要插入的位置
} while (t != null);
}
else {
// 如果比較器爲空，則使用key作爲比較器進行比較
// 這裏要求key不能爲空，並且必須實現Comparable接口
if (key == null)
throw new NullPointerException();
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);
} while (t != null);
}
// 找到新節點的父節點後，創建節點對象
Entry<K,V> e = new Entry<K,V>(key, value, parent);
// 如果新節點key的值小於父節點key的值，則插在父節點的左側
if (cmp < 0)
parent. left = e;
// 如果新節點key的值大於父節點key的值，則插在父節點的右側
else
parent. right = e;
// 插入新的節點後，爲了保持紅黑樹平衡，對紅黑樹進行調整
fixAfterInsertion(e);
// map元素個數+1
size++;
modCount++;
return null;
}
/** 新增節點後對紅黑樹的調整方法 */
private void fixAfterInsertion(Entry<K,V> x) {
// 將新插入節點的顏色設置爲紅色
x. color = RED;
// while循環，保證新插入節點x不是根節點或者新插入節點x的父節點不是紅色（這兩種情況不需要調整）
while (x != null && x != root && x. parent.color == RED) {
// 如果新插入節點x的父節點是祖父節點的左孩子
if (parentOf(x) == leftOf(parentOf (parentOf(x)))) {
// 取得新插入節點x的叔叔節點
Entry<K,V> y = rightOf(parentOf (parentOf(x)));
// 如果新插入x的父節點是紅色-------------------①
if (colorOf(y) == RED) {
// 將x的父節點設置爲黑色
setColor(parentOf (x), BLACK);
// 將x的叔叔節點設置爲黑色
setColor(y, BLACK);
// 將x的祖父節點設置爲紅色
setColor(parentOf (parentOf(x)), RED);
// 將x指向祖父節點，如果x的祖父節點的父節點是紅色，按照上面的步奏繼續循環
x = parentOf(parentOf (x));
} else {
// 如果新插入x的叔叔節點是黑色或缺少，且x的父節點是祖父節點的右孩子-------------------②
if (x == rightOf( parentOf(x))) {
// 左旋父節點
x = parentOf(x);
rotateLeft(x);
}
// 如果新插入x的叔叔節點是黑色或缺少，且x的父節點是祖父節點的左孩子-------------------③
// 將x的父節點設置爲黑色
setColor(parentOf (x), BLACK);
// 將x的祖父節點設置爲紅色
setColor(parentOf (parentOf(x)), RED);
// 右旋x的祖父節點
rotateRight( parentOf(parentOf (x)));
}
} else { // 如果新插入節點x的父節點是祖父節點的右孩子，下面的步奏和上面的相似，只不過左旋右旋的區分，不在細講
Entry<K,V> y = leftOf(parentOf (parentOf(x)));
if (colorOf(y) == RED) {
setColor(parentOf (x), BLACK);
setColor(y, BLACK);
setColor(parentOf (parentOf(x)), RED);
x = parentOf(parentOf (x));
} else {
if (x == leftOf( parentOf(x))) {
x = parentOf(x);
rotateRight(x);
}
setColor(parentOf (x), BLACK);
setColor(parentOf (parentOf(x)), RED);
rotateLeft( parentOf(parentOf (x)));
}
}
}
// 最後將根節點設置爲黑色，不管當前是不是紅色，反正根節點必須是黑色
root.color = BLACK;
}
/**
* 對紅黑樹的節點(x)進行左旋轉
*
* 左旋示意圖(對節點x進行左旋)：
* px px
* / /
* x y
* / \ --(左旋)-- / \
* lx y x ry
* / \ / \
* ly ry lx ly
*
*/
private void rotateLeft(Entry<K,V> p) {
if (p != null) {
// 取得要選擇節點p的右孩子
Entry<K,V> r = p. right;
// "p"和"r的左孩子"的相互指向...
// 將"r的左孩子"設爲"p的右孩子"
p. right = r.left ;
// 如果r的左孩子非空，將"p"設爲"r的左孩子的父親"
if (r.left != null)
r. left.parent = p;
// "p的父親"和"r"的相互指向...
// 將"p的父親"設爲"y的父親"
r. parent = p.parent ;
// 如果"p的父親"是空節點，則將r設爲根節點
if (p.parent == null)
root = r;
// 如果p是它父節點的左孩子，則將r設爲"p的父節點的左孩子"
else if (p.parent. left == p)
p. parent.left = r;
else
// 如果p是它父節點的左孩子，則將r設爲"p的父節點的左孩子"
p. parent.right = r;
// "p"和"r"的相互指向...
// 將"p"設爲"r的左孩子"
r. left = p;
// 將"p的父節點"設爲"r"
p. parent = r;
}
}
/**
* 對紅黑樹的節點進行右旋轉
*
* 右旋示意圖(對節點y進行右旋)：
* py py
* / /
* y x
* / \ --(右旋)-- / \
* x ry lx y
* / \ / \
* lx rx rx ry
*
*/
private void rotateRight(Entry<K,V> p) {
if (p != null) {
// 取得要選擇節點p的左孩子
Entry<K,V> l = p. left;
// 將"l的右孩子"設爲"p的左孩子"
p. left = l.right ;
// 如果"l的右孩子"不爲空的話，將"p"設爲"l的右孩子的父親"
if (l.right != null) l. right.parent = p;
// 將"p的父親"設爲"l的父親"
l. parent = p.parent ;
// 如果"p的父親"是空節點，則將l設爲根節點
if (p.parent == null)
root = l;
// 如果p是它父節點的右孩子，則將l設爲"p的父節點的右孩子"
else if (p.parent. right == p)
p. parent.right = l;
//如果p是它父節點的左孩子，將l設爲"p的父節點的左孩子"
else p.parent .left = l;
// 將"p"設爲"l的右孩子"
l. right = p;
// 將"l"設爲"p父節點"
p. parent = l;
}
}單純的看代碼和註釋，絕對會發出，cha這是什麼亂七八糟的，任誰也看不懂，所以一定要結合上面的圖解，不懂了就看看圖，然後動手畫一下。
紅黑樹的刪除原理及TreeMap的remove實現
相比添加，紅黑樹的刪除顯得更加複雜了。看下紅黑樹的刪除需要哪幾個步奏：
- 將紅黑樹當成一顆二叉查找樹，將節點刪除。
- 通過旋轉和着色，使它恢復平衡，重新變成一顆符合規則的紅黑樹。
刪除節點的關鍵是：
- 如果刪除的是紅色節點，不會違背紅黑樹的規則。
- 如果刪除的是黑色節點，那麼這個路徑上就少了一個黑色節點，則違背了紅黑樹的規則。
來看下紅黑樹刪除節點會有哪幾種情況：
（1）被刪除的節點沒有孩子節點，即葉子節點。可直接刪除。
（2）被刪除的節點只有一個孩子節點，那麼直接刪除該節點，然後用它的孩子節點頂替它的位置。
（3）被刪除的節點有兩個孩子節點。這種情況二叉樹的刪除有一個技巧，就是查找到要刪除的節點X，接着我們找到它左子樹的最大元素M，或者它右子樹的最小元素M，交換X和M的值，然後刪除節點M。此時M就最多隻有一個子節點N(若是左子樹則沒有右子節點，若是右子樹則沒有左子節點 )，若M沒有孩子則進入(1)的情況，否則進入(2)的情況。
如上圖，我們假定節點X是要刪除的節點，而節點M是找到X右子樹的最小元素，所以節點M是X的替代節點，也就是說M是真正要刪除的節點。上面我們分析了此時的M只會有一個子節點N，當刪除節點M後，N將替代M作爲M節點的父節點的子節點。刪除的節點M是黑色（刪除紅色不影響上面分析了），此時如果N是紅色，只需將N設置爲黑色，就會重新達到平衡，不會出現該路徑上少了一個黑色節點的情況；但是如果N是紅色，情況則比較複雜，需要對紅黑樹進行調整，而這種情況又分爲了以下幾種，下面進行圖解：
①N的兄弟節點B是紅色。方法是：交換P和B的顏色，左旋父節點P。此時並未完成平衡，左子樹仍然少了一個黑色節點，進入情況③。（B爲紅色，P必然爲黑色）
②N的父節點P是黑色，且兄弟節點B和它的兩個孩子節點也都是黑色。方法是：將N的兄弟節點B改爲紅色，這樣從P出發到葉子節點的路徑都包含了相同的黑色節點，但是，對於節點P這個子樹，P的父節點G到P的葉子節點路徑上的黑色節點就少了一個，此時需要將P整體看做一個節點，繼續調整。
③N的父節點P爲紅色，兄弟節點B和它的兩個孩子節點也都是黑色。此時只需要交換P和B的顏色，將P改爲黑色，B改爲紅色，則可到達平衡。這相當於既然節點N路徑少了一個黑色節點，那麼B路徑也少一個黑色節點，這兩個路徑達到平衡，爲了防止P路徑少一個黑色節點，將P節點置黑，則達到最終平衡。
④N的兄弟節點B是黑色，B的左孩子節點BL是紅色，B的右孩子節點BR是黑色，P爲任意顏色。方法是：交換B和BL的顏色，右旋節點B。此時N子樹路徑並沒有增加黑色節點，也就是沒有達到平衡，此時進入下一種情況⑤。
⑤N的兄弟節點B是黑色，B的右孩子節點BR是紅色，B的左孩子節點BL任意顏色，P任意顏色。方法是：BR變爲黑色，P變爲黑色，B變爲P的顏色；左旋節點B。首先給N路徑增加一個黑色節點P，P原位置上的顏色不變；S路徑少了一個黑色節點，於是將BR改爲黑色，最終達到了平衡。
上面對紅黑樹刪除的原理和刪除過程中遇到的情況進行了分析說明，我們得到的結論是紅黑樹的刪除遇到的主要問題就是被刪除路徑上的黑色節點減少，於是需要進行一系列旋轉和着色，當然上面的情況是基於M是X右子樹的最小元素，而M如果是X左子樹的最大元素和上面的情況是相似的，我們具體看下TreeMap的代碼是怎麼實現的：
public V remove(Object key) {
// 根據key查找到對應的節點對象
Entry<K,V> p = getEntry(key);
if (p == null)
return null;
// 記錄key對應的value，供返回使用
V oldValue = p. value;
// 刪除節點
deleteEntry(p);
return oldValue;
}
private void deleteEntry(Entry<K,V> p) {
modCount++;
// map容器的元素個數減一
size--;
// If strictly internal, copy successor's element to p and then make p
// point to successor.
// 如果被刪除的節點p的左孩子和右孩子都不爲空，則查找其替代節點-----------這裏表示要刪除的節點有兩個孩子（3）
if (p.left != null && p. right != null) {
// 查找p的替代節點
Entry<K,V> s = successor (p);
p. key = s.key ;
p. value = s.value ;
// 將p指向替代節點，※※※※※※從此之後的p不再是原先要刪除的節點p，而是替代者p（就是圖解裏面講到的M） ※※※※※※
p = s;
} // p has 2 children
// Start fixup at replacement node, if it exists.
// replacement爲替代節點p的繼承者（就是圖解裏面講到的N），p的左孩子存在則用p的左孩子替代，否則用p的右孩子
Entry<K,V> replacement = (p. left != null ? p.left : p. right);
if (replacement != null) { // 如果上面的if有兩個孩子不通過--------------這裏表示要刪除的節點只有一個孩子（2）
// Link replacement to parent
// 將p的父節點拷貝給替代節點
replacement. parent = p.parent ;
// 如果替代節點p的父節點爲空，也就是p爲跟節點，則將replacement設置爲根節點
if (p.parent == null)
root = replacement;
// 如果替代節點p是其父節點的左孩子，則將replacement設置爲其父節點的左孩子
else if (p == p.parent. left)
p. parent.left = replacement;
// 如果替代節點p是其父節點的左孩子，則將replacement設置爲其父節點的右孩子
else
p. parent.right = replacement;
// Null out links so they are OK to use by fixAfterDeletion.
// 將替代節點p的left、right、parent的指針都指向空，即解除前後引用關係（相當於將p從樹種摘除），使得gc可以回收
p. left = p.right = p.parent = null;
// Fix replacement
// 如果替代節點p的顏色是黑色，則需要調整紅黑樹以保持其平衡
if (p.color == BLACK)
fixAfterDeletion(replacement);
} else if (p.parent == null) { // return if we are the only node.
// 如果要替代節點p沒有父節點，代表p爲根節點，直接刪除即可
root = null;
} else { // No children. Use self as phantom replacement and unlink.
// 判斷進入這裏說明替代節點p沒有孩子--------------這裏表示沒有孩子則直接刪除（1）
// 如果p的顏色是黑色，則調整紅黑樹
if (p.color == BLACK)
fixAfterDeletion(p);
// 下面刪除替代節點p
if (p.parent != null) {
// 解除p的父節點對p的引用
if (p == p.parent .left)
p. parent.left = null;
else if (p == p.parent. right)
p. parent.right = null;
// 解除p對p父節點的引用
p. parent = null;
}
}
}
/**
* 查找要刪除節點的替代節點
*/
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
if (t == null)
return null;
// 查找右子樹的最左孩子
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;
}
}
/** From CLR */
private void fixAfterDeletion(Entry<K,V> x) {
// while循環，保證要刪除節點x不是跟節點，並且是黑色（根節點和紅色不需要調整）
while (x != root && colorOf (x) == BLACK) {
// 如果要刪除節點x是其父親的左孩子
if (x == leftOf( parentOf(x))) {
// 取出要刪除節點x的兄弟節點
Entry<K,V> sib = rightOf(parentOf (x));
// 如果刪除節點x的兄弟節點是紅色---------------------------①
if (colorOf(sib) == RED) {
// 將x的兄弟節點顏色設置爲黑色
setColor(sib, BLACK);
// 將x的父節點顏色設置爲紅色
setColor(parentOf (x), RED);
// 左旋x的父節點
rotateLeft( parentOf(x));
// 將sib重新指向旋轉後x的兄弟節點 ，進入else的步奏③
sib = rightOf(parentOf (x));
}
// 如果x的兄弟節點的兩個孩子都是黑色-------------------------③
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf (sib)) == BLACK) {
// 將兄弟節點的顏色設置爲紅色
setColor(sib, RED);
// 將x的父節點指向x，如果x的父節點是黑色，需要將x的父節點整天看做一個節點繼續調整-------------------------②
x = parentOf(x);
} else {
// 如果x的兄弟節點右孩子是黑色，左孩子是紅色-------------------------④
if (colorOf(rightOf(sib)) == BLACK) {
// 將x的兄弟節點的左孩子設置爲黑色
setColor(leftOf (sib), BLACK);
// 將x的兄弟節點設置爲紅色
setColor(sib, RED);
// 右旋x的兄弟節點
rotateRight(sib);
// 將sib重新指向旋轉後x的兄弟節點，進入步奏⑤
sib = rightOf(parentOf (x));
}
// 如果x的兄弟節點右孩子是紅色-------------------------⑤
setColor(sib, colorOf (parentOf(x)));
// 將x的父節點設置爲黑色
setColor(parentOf (x), BLACK);
// 將x的兄弟節點的右孩子設置爲黑色
setColor(rightOf (sib), BLACK);
// 左旋x的父節點
rotateLeft( parentOf(x));
// 達到平衡，將x指向root，退出循環
x = root;
}
} else { // symmetric // 如果要刪除節點x是其父親的右孩子，和上面情況一樣，這裏不再細講
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);
}刪除相對來說更加複雜，還是那句話一定要對照着圖解看代碼，否則是讀不懂的，別問我是怎麼看懂得，我n天不看再看代碼也不知道123了。
終於看完了紅黑樹的增加和刪除，下面來看個稍微簡單的查詢：
紅黑樹的查詢
public V get(Object key) {
Entry<K,V> p = getEntry(key);
return (p==null ? null : p. value);
}
final Entry<K,V> getEntry(Object key) {
// Offload comparator-based version for sake of performance
if (comparator != null)
// 如果比較器爲空，只是用key作爲比較器查詢
return getEntryUsingComparator(key);
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
// 取得root節點
Entry<K,V> p = root;
// 從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) {
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;
}TreeMap遍歷方式
遍歷TreeMap的鍵值對
第一步：根據entrySet()獲取TreeMap的“鍵值對”的Set集合。
第二步：通過Iterator迭代器遍歷“第一步”得到的集合。
// 假設map是TreeMap對象
// map中的key是String類型，value是Integer類型
Integer integ = null;
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
// 獲取key
key = (String)entry.getKey();
// 獲取value
integ = (Integer)entry.getValue();
}遍歷TreeMap的鍵
第一步：根據keySet()獲取TreeMap的“鍵”的Set集合。
第二步：通過Iterator迭代器遍歷“第一步”得到的集合。
// 假設map是TreeMap對象
// map中的key是String類型，value是Integer類型
String key = null;
Integer integ = null;
Iterator iter = map.keySet().iterator();
while (iter.hasNext()) {
// 獲取key
key = (String)iter.next();
// 根據key，獲取value
integ = (Integer)map.get(key);
}遍歷TreeMap的值
第一步：根據value()獲取TreeMap的“值”的集合。
第二步：通過Iterator迭代器遍歷“第一步”得到的集合。
// 假設map是TreeMap對象
// map中的key是String類型，value是Integer類型
Integer value = null;
Collection c = map.values();
Iterator iter= c.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}TreeMap示例
下面通過實例來學習如何使用TreeMap
import java.util.*;
/**
* @desc TreeMap測試程序
*
* @author skywang
*/
public class TreeMapTest {
public static void main(String[] args) {
// 測試常用的API
testTreeMapOridinaryAPIs();
// 測試TreeMap的導航函數
//testNavigableMapAPIs();
// 測試TreeMap的子Map函數
//testSubMapAPIs();
}
/**
* 測試常用的API
*/
private static void testTreeMapOridinaryAPIs() {
// 初始化隨機種子
Random r = new Random();
// 新建TreeMap
TreeMap tmap = new TreeMap();
// 添加操作
tmap.put("one", r.nextInt(10));
tmap.put("two", r.nextInt(10));
tmap.put("three", r.nextInt(10));
System.out.printf("\n ---- testTreeMapOridinaryAPIs ----\n");
// 打印出TreeMap
System.out.printf("%s\n",tmap );
// 通過Iterator遍歷key-value
Iterator iter = tmap.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
System.out.printf("next : %s - %s\n", entry.getKey(), entry.getValue());
}
// TreeMap的鍵值對個數
System.out.printf("size: %s\n", tmap.size());
// containsKey(Object key) :是否包含鍵key
System.out.printf("contains key two : %s\n",tmap.containsKey("two"));
System.out.printf("contains key five : %s\n",tmap.containsKey("five"));
// containsValue(Object value) :是否包含值value
System.out.printf("contains value 0 : %s\n",tmap.containsValue(new Integer(0)));
// remove(Object key) ： 刪除鍵key對應的鍵值對
tmap.remove("three");
System.out.printf("tmap:%s\n",tmap );
// clear() ： 清空TreeMap
tmap.clear();
// isEmpty() : TreeMap是否爲空
System.out.printf("%s\n", (tmap.isEmpty()?"tmap is empty":"tmap is not empty") );
}
/**
* 測試TreeMap的子Map函數
*/
public static void testSubMapAPIs() {
// 新建TreeMap
TreeMap tmap = new TreeMap();
// 添加“鍵值對”
tmap.put("a", 101);
tmap.put("b", 102);
tmap.put("c", 103);
tmap.put("d", 104);
tmap.put("e", 105);
System.out.printf("\n ---- testSubMapAPIs ----\n");
// 打印出TreeMap
System.out.printf("tmap:\n\t%s\n", tmap);
// 測試 headMap(K toKey)
System.out.printf("tmap.headMap(\"c\"):\n\t%s\n", tmap.headMap("c"));
// 測試 headMap(K toKey, boolean inclusive)
System.out.printf("tmap.headMap(\"c\", true):\n\t%s\n", tmap.headMap("c", true));
System.out.printf("tmap.headMap(\"c\", false):\n\t%s\n", tmap.headMap("c", false));
// 測試 tailMap(K fromKey)
System.out.printf("tmap.tailMap(\"c\"):\n\t%s\n", tmap.tailMap("c"));
// 測試 tailMap(K fromKey, boolean inclusive)
System.out.printf("tmap.tailMap(\"c\", true):\n\t%s\n", tmap.tailMap("c", true));
System.out.printf("tmap.tailMap(\"c\", false):\n\t%s\n", tmap.tailMap("c", false));
// 測試 subMap(K fromKey, K toKey)
System.out.printf("tmap.subMap(\"a\", \"c\"):\n\t%s\n", tmap.subMap("a", "c"));
// 測試
System.out.printf("tmap.subMap(\"a\", true, \"c\", true):\n\t%s\n",
tmap.subMap("a", true, "c", true));
System.out.printf("tmap.subMap(\"a\", true, \"c\", false):\n\t%s\n",
tmap.subMap("a", true, "c", false));
System.out.printf("tmap.subMap(\"a\", false, \"c\", true):\n\t%s\n",
tmap.subMap("a", false, "c", true));
System.out.printf("tmap.subMap(\"a\", false, \"c\", false):\n\t%s\n",
tmap.subMap("a", false, "c", false));
// 測試 navigableKeySet()
System.out.printf("tmap.navigableKeySet():\n\t%s\n", tmap.navigableKeySet());
// 測試 descendingKeySet()
System.out.printf("tmap.descendingKeySet():\n\t%s\n", tmap.descendingKeySet());
}
/**
* 測試TreeMap的導航函數
*/
public static void testNavigableMapAPIs() {
// 新建TreeMap
NavigableMap nav = new TreeMap();
// 添加“鍵值對”
nav.put("aaa", 111);
nav.put("bbb", 222);
nav.put("eee", 333);
nav.put("ccc", 555);
nav.put("ddd", 444);
System.out.printf("\n ---- testNavigableMapAPIs ----\n");
// 打印出TreeMap
System.out.printf("Whole list:%s%n", nav);
// 獲取第一個key、第一個Entry
System.out.printf("First key: %s\tFirst entry: %s%n",nav.firstKey(), nav.firstEntry());
// 獲取最後一個key、最後一個Entry
System.out.printf("Last key: %s\tLast entry: %s%n",nav.lastKey(), nav.lastEntry());
// 獲取“小於/等於bbb”的最大鍵值對
System.out.printf("Key floor before bbb: %s%n",nav.floorKey("bbb"));
// 獲取“小於bbb”的最大鍵值對
System.out.printf("Key lower before bbb: %s%n", nav.lowerKey("bbb"));
// 獲取“大於/等於bbb”的最小鍵值對
System.out.printf("Key ceiling after ccc: %s%n",nav.ceilingKey("ccc"));
// 獲取“大於bbb”的最小鍵值對
System.out.printf("Key higher after ccc: %s%n\n",nav.higherKey("ccc"));
}
}運行結果：
{one=8, three=4, two=2}
next : one - 8
next : three - 4
next : two - 2
size: 3
contains key two : true
contains key five : false
contains value 0 : false
tmap:{one=8, two=2}
tmap is empty總結
到此TreeMap就分析完了，其實大部分時間都在整理紅黑樹，在數據結構中樹是比較難懂的一個，其算法也比較複雜，對於樹的理解一定要多看圖畫圖，要明白這麼做是爲了解決什麼問題，這麼做又有什麼好處，當然看一遍看不懂就要多看幾遍了。什麼你問我平時工作中會用到樹嗎？那真的要看你做的什麼性質的工作，如果是web、客戶端開發，調用api就可以了對吧，如果是從事底層開發，比如文件系統，存儲系統，緩存等工作必須是需要的。當然就算用不到，理解了也是有益無害的。
參考
該文爲本人學習的筆記，方便以後自己跳槽前複習。參考網上各大帖子，取其精華整合自己的理解而成。集合框架源碼面試經常會問，所以解讀源碼十分必要,希望對你有用。
Java提高篇（二七）-----TreeMap
Java 集合系列12之 TreeMap詳細介紹(源碼解析)和使用示例
給jdk寫註釋系列之jdk1.6容器(7)-TreeMap源碼解析
紅黑樹(五)之 Java的實現 - 如果天空不死
原文鏈接：http://www.jianshu.com/p/210c2f4ca130
著作權歸作者所有，轉載請聯繫作者獲得授權，並標註“簡書作者”。
