- 上篇中介紹了jdk1.7和jdk1.8中的HashMap【 JAVA集合：HashMap深度解析（版本對比）】1.8中的HashMap引入了紅黑樹的結構，補充一下對紅黑樹的理解，這裡以TreeMap中的紅黑樹結構為例，HashMap中的紅黑樹結構稍微複雜一點，因為涉及到連結串列和紅黑樹結構的相互轉換（以下原始碼來自jdk1.8）
紅黑樹是一種特殊的平衡二叉樹，不追求嚴格的平衡，可以在O(log n)時間內做查詢、插入和刪除，插入節點最多隻需要兩次旋轉即可達到平衡，效率很高。
規則：
- 每個節點都有顏色（紅或黑）；
- 根節點必須是黑色的；
- 葉子節點（null節點）是黑的，即每個節點都有兩個子節點（其中一個或者兩個可能是null節點）；
- 相連節點不能都是紅色（紅色節點的父節點和子節點必須為黑色）；
- 任意節點到它所有的葉子節點的路徑都含有相同的黑色節點的數量。
結構
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; //預設黑色
｝
複製程式碼
【引申規則：根據規則4和5，如果一個節點只有一個子節點，那麼這個子節點肯定是紅色的並且沒有子節點。（如上圖的22節點和65節點）】
基本方法
- 獲取節點顏色，葉子節點（null節點）的顏色是黑色
private static <K,V> boolean colorOf(Entry<K,V> p) {
return (p == null ? BLACK : p.color);
}
複製程式碼變化
為了保證規則5成立，插入節點的顏色總是紅色的，但這時候可能會造成規則4不成立，就需要進行調整，紅黑樹有兩種調整操作：
- 變色（改變節點的顏色）
- 旋轉（左旋轉和右旋轉）
- 左旋轉示意圖（對節點E左旋轉，圖片來自網際網路）
private void rotateLeft(Entry<K,V> p) {
if (p != null) {
Entry<K,V> r = p.right;
//把右孩子的左孩子節點置為當前節點的右孩子節點(上圖中的betweenEandS節點變化)
p.right = r.left;
if (r.left != null)
r.left.parent = p;
//把右孩子節點放到當前節點位置(上圖中S節點換到E節點位置)
r.parent = p.parent;
if (p.parent == null)
root = r;
else if (p.parent.left == p)
p.parent.left = r;
else
p.parent.right = r;
//當前節點變成右孩子節點的左孩子節點(E節點變成S節點的左孩子)
r.left = p;
p.parent = r;
}
}
複製程式碼- 右旋轉示意圖（對節點S右旋轉，圖片來自網際網路）
private void rotateRight(Entry<K,V> p) {
if (p != null) {
Entry<K,V> l = p.left;
p.left = l.right;
if (l.right != null) l.right.parent = p;
l.parent = p.parent;
if (p.parent == null)
root = l;
else if (p.parent.right == p)
p.parent.right = l;
else p.parent.left = l;
l.right = p;
p.parent = l;
}
}
複製程式碼put方法
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) { //如果根節點是null，直接插入
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) { //如果實現了comparator就用comparator比較大小，否則用通用的Comparable比較大小
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;
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<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e); //插入之後可能違反了紅黑樹的規則，需要進行調整
size++;
modCount++;
return null;
}
複製程式碼fixAfterInsertion插入新節點之後的調整函式（重點）
private void fixAfterInsertion(Entry<K,V> x) {
x.color = RED; //新插入的節點都是紅色的
while (x != null && x != root && x.parent.color == RED) { //如果父節點也是紅色，違反了規則4，就需要調整。
if (parentOf(x) == leftOf(parentOf(parentOf(x)))) { //如果x的父節點是x的祖父節點的左孩子，
Entry<K,V> y = rightOf(parentOf(parentOf(x))); //y表示x的叔父節點（x的父節點的兄弟節點）
/**
* 情況1：如果x的父節點和叔父節點都是紅色的
* 則祖父節點肯定是黑色的
* 把祖父節點變成紅色的，父親節點和叔父節點變成黑色的
* （保證從祖父節點到其所有葉子節點的黑色節點數量保持不變）
* 此時祖父節點從黑色變成紅色，可能違反了規則4，while迴圈繼續對祖父節點進行調整
*/
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK); //父親節點紅變黑
setColor(y, BLACK); //叔父節點紅變黑
setColor(parentOf(parentOf(x)), RED); //祖父節點黑變紅
x = parentOf(parentOf(x)); //while迴圈繼續對祖父進行調整
} else {
/**
* 情況2：x的叔父節點是黑色的（我們用p代表x的父節點，pp代表x的祖父節點，pr代表x的叔父節點）
* x和p是紅色，pr和pp是黑色，不能直接變色，這種情況下我們把p變黑，pp變紅，
* 然後對pp右旋轉，左右分支的黑色節點數量不變
* 但是右旋轉會使p的右孩子變成pp的左孩子，pp現在是紅色，如果x是p的右孩子（紅色），旋轉過去就會衝突。
* 所以需要提前判斷x如果是p的右孩子，對x的父節點進行左旋轉（參照上面的左旋轉）
* x變成父節點，p變成左孩子，把紅色節點移到左分支，x的右孩子是黑色，保證下面的祖父節點右旋轉不會發生衝突
* 右旋轉之後新祖父節點到各個子孫節點的黑色節點數量仍然保持不變，並且是黑色的，不會再和它的父節點衝突，調整到此結束。
* 即插入操作最多旋轉操作兩次就可以解決衝突
*/
if (x == rightOf(parentOf(x))) {
x = parentOf(x); //x指向父親節點
rotateLeft(x); //對x進行左旋轉，把紅色節點移到左邊
}
setColor(parentOf(x), BLACK); //父節點變色
setColor(parentOf(parentOf(x)), RED); //祖父節點變色
rotateRight(parentOf(parentOf(x))); //祖父節點右旋轉
}
} else { //下面這種情況對上面的左右對稱，操作原理一樣
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)));
}
}
}
/**
* 保證根節點是黑色
* 假設x的父節點和叔父節點都是紅色，祖父節點是黑色並且是根節點
* 符合情況1，那麼把父節點叔父節點變黑，祖父節點變紅，衝突解決
* x = parentOf(parentOf(x));此時x是根節點不會再調整，但是此時x是紅色的，不滿足規則2，所以把根節點置黑。
*/
root.color = BLACK;
}
複製程式碼示例
以下圖紅黑樹為例
現在我們要增加一個節點50，放在節點47的右子樹上。
新增節點和父節點衝突，叔父節點是紅色的，進行變色操作，把父親節點和叔父節點都變成黑色，祖父節點變成紅色，然後再對祖父節點進行調整。
if (colorOf(y) == RED) {
setColor(parentOf(x), BLACK);
setColor(y, BLACK);
setColor(parentOf(parentOf(x)), RED);
x = parentOf(parentOf(x));
}
複製程式碼
叔父節點y是黑色的，並且x是右孩子，先進行左旋轉，把紅色節點轉移到左分支。
if (x == rightOf(parentOf(x))) {
x = parentOf(x);
rotateLeft(x);
}
複製程式碼
再把x的父節點變黑，祖父節點變紅，然後把祖父節點右旋轉。
setColor(parentOf(x), BLACK);
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
複製程式碼
最多兩次旋轉即可解決衝突。
delete方法
private void deleteEntry(Entry<K,V> p) {
modCount++;
size--;
// If strictly internal, copy successor's element to p and then make p
// point to successor.
if (p.left != null && p.right != null) { //如果刪除的節點有兩個孩子，不能直接刪除，需要查詢繼承者
Entry<K,V> s = successor(p); //successor函式查詢繼承者s，然後把key和value賦值給當前刪除的節點，繼承者s變成需要刪除的節點
p.key = s.key;
p.value = s.value;
p = s;
} // p has 2 children
/**
* 繼承節點沒有左孩子節點，所以此時p只有一個孩子節點或者沒有孩子節點
*/
// Start fixup at replacement node, if it exists.
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
/**
* 如果有一個孩子節點，用這個孩子節點replacement替換掉需要刪除的節點p
* 根據上面的引申規則，replacement節點肯定是紅色的，並且沒有子節點
*/
if (replacement != null) {
// Link replacement to parent
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;
// Null out links so they are OK to use by fixAfterDeletion.
// 斷開節點p和其他節點的連結
p.left = p.right = p.parent = null;
/**
* 如果刪除的節點p是紅色的，直接刪除，不需要更多的處理
* 如果是黑色的，就需要replacement節點進行調整
* 因為replacement節點是紅色的，所以fixAfterDeletion方法也只是把replacement節點變黑
if (p.color == BLACK)
fixAfterDeletion(replacement);
} else if (p.parent == null) { // p沒有孩子節點，並且沒有父親節點，則p是根節點，直接刪除
root = null;
} else { // p沒有孩子節點，並且不是根節點，如果是紅色，直接刪除，如果是黑色，則需要進行調整
if (p.color == BLACK)
fixAfterDeletion(p);
if (p.parent != null) { //調整完之後把p刪除
if (p == p.parent.left)
p.parent.left = null;
else if (p == p.parent.right)
p.parent.right = null;
p.parent = null;
}
}
}
複製程式碼successor方法（查詢繼承者）
- 當需要刪除的節點有兩個孩子節點時才呼叫此方法。即右孩子節點 != null
static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
if (t == null)
return null;
/**
* 右孩子節點不為null，查詢右子樹中最左邊的節點，這個節點的值大於節點t
* 並且是右子樹中最小的節點，用來當作繼承者替換節點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;
}
}
複製程式碼fixAfterDeletion刪除節點的調整函式（重點）
演算法思想：我們要刪除一個黑色節點，這會破壞規則5，調整有3種情景：
- 如果兄弟節點是紅色的，經過變色旋轉，在x節點上面增加一個紅色的父親節點，並且不破壞其他分支的黑色節點數量。
- 兄弟節點是黑色的，如果兄弟節點的子節點都是黑色的，直接把黑色節點變紅，即減少兄弟分支的黑色節點數量，然後對其父節點進行調整；
- 兄弟節點是黑色的，但其有紅色的孩子節點，不能直接變紅。如果左孩子是紅色節點，經過變色和右旋轉把紅色節點移到右邊。此時再經過變色，並對x的父節點進行左旋轉，在x節點的上面增加一個黑色節點，並且不破壞其他分支的黑色節點數量，調整結束。
private void fixAfterDeletion(Entry<K,V> x) {
while (x != root && colorOf(x) == BLACK) { //節點x不是根節點並且是黑色才進行處理
if (x == leftOf(parentOf(x))) { //x是其父節點的左孩子
Entry<K,V> sib = rightOf(parentOf(x)); //sib表示x的兄弟節點
/**
* 如果兄弟節點是紅色的，那麼父節點肯定是黑色的
* 把兄弟節點變黑，父節點變紅，然後對父節點左旋轉
* 兄弟節點變成父節點，並且到右子樹的黑色節點數量不變（由1黑1紅變成1黑）
*
* 即情景1，在x節點上增加一個父節點（紅色）。
*/
if (colorOf(sib) == RED) {
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x)); //旋轉之後重新賦值兄弟節點sib，原sib變成x的祖父節點（見左旋轉動圖）
}
/**
* 進行上一步的判斷處理後，此時兄弟節點肯定是黑色的。
* 如果兄弟節點的孩子節點都是黑色的，我們就可以把兄弟節點變紅。
* 然後while迴圈繼續調整其父節點，即情景2。
*/
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
} else { //兄弟節點不能直接變紅的情況下，即情景3
/**
* 如果兄弟節點的左孩子是紅色，右孩子是黑色
* 兄弟節點的左孩子變黑，兄弟節點變紅，對兄弟節點右旋轉，把紅色節點轉移到右分支
*/
if (colorOf(rightOf(sib)) == BLACK) {
setColor(leftOf(sib), BLACK);
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x)); //重新賦值兄弟節點
}
/**
* 經過上一步判斷處理，兄弟節點是黑色，兄弟節點的左孩子是黑色，兄弟節點的右孩子是紅色，
* 把兄弟節點變成父節點的顏色，兄弟節點的右孩子變成黑色（不破壞右分支的規則），父節點變成黑色，對父親節點左旋轉，
* 主要就在x節點的上面增加了一個黑色的父節點，即情景3，調整結束。
*/
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
}
} else { // 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);
}
複製程式碼示例
- 刪除的節點只有一個子節點（刪除390），根據上面的引申規則，這個節點肯定是黑色，子節點是紅色
- 刪除紅色的節點並且沒有子節點（刪除833）
- 刪除黑色的節點並且沒有子節點（刪除22）
- 兄弟節點是紅色的情況
變色+旋轉，給x節點增加一個紅色的父親節點
if (colorOf(sib) == RED) {
setColor(sib, BLACK);
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
sib = rightOf(parentOf(x));
}
複製程式碼
此時x的新兄弟節點是黑色，並且孩子節點全是黑色（葉子節點是黑色的），把兄弟節點變色，然後x指向父節點，while迴圈繼續調整。
if (colorOf(leftOf(sib)) == BLACK &&
colorOf(rightOf(sib)) == BLACK) {
setColor(sib, RED);
x = parentOf(x);
複製程式碼
節點是紅色，跳出迴圈。迴圈外把該節點變黑。
while (x != root && colorOf(x) == BLACK) {}
setColor(x, BLACK);
複製程式碼
方法返回後，deleteEntry方法把22節點刪除，整個過程結束。
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;
}
複製程式碼
- 兄弟節點是黑色的情況
上面是旋轉變化過程中其實已經遇見了這種情況，並且兄弟節點的孩子節點全是黑色，可以直接變色處理，下面來看一下，兄弟節點是黑色，並且有孩子節點是紅色的情況
繼續上面的紅黑樹，下面刪除65節點
兄弟節點是黑色，並且有紅色的孩子節點，針對x是左孩子的情況下，如果紅色節點是左孩子，需要通過旋轉操作移到右邊
if (colorOf(rightOf(sib)) == BLACK) {
setColor(leftOf(sib), BLACK);
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x));
}
複製程式碼
然後再進行變色旋轉操作，給x節點增加一個黑色的父節點。x = root結束迴圈。
setColor(sib, colorOf(parentOf(x)));
setColor(parentOf(x), BLACK);
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
複製程式碼
方法返回，deleteEntry方法把65節點刪除，整個過程結束。
- 刪除節點有兩個孩子節點的情況。
刪除節點55，該節點有兩個孩子節點，deleteEntry方法中會查詢繼承者節點，即圖中的65節點，把65節點的key和value賦值給55節點，然後轉化為刪除65節點。
if (p.left != null && p.right != null) {
Entry<K,V> s = successor(p);
p.key = s.key;
p.value = s.value;
p = s;
}
複製程式碼
因為繼承者節點沒有左孩子節點，所以這個問題又變成了刪除一個孩子節點或者無孩子節點的問題。（參照上面）