JAVA集合：TreeMap紅黑樹深度解析
- 上篇中介紹了jdk1.7和jdk1.8中的HashMap【 JAVA集合：HashMap深度解析（版本對比）】1.8中的HashMap引入了紅黑樹的結構，補充一下對紅黑樹的理解，這裏以TreeMap中的紅黑樹結構爲例，HashMap中的紅黑樹結構稍微複雜一點，由於涉及到鏈表和紅黑樹結構的相互轉換（如下源碼來自jdk1.8）
紅黑樹是一種特殊的平衡二叉樹，不追求嚴格的平衡，能夠在O(log n)時間內作查找、插入和刪除，插入節點最多隻須要兩次旋轉便可達到平衡，效率很高。java
規則：node
- 每一個節點都有顏色（紅或黑）；
- 根節點必須是黑色的；
- 葉子節點（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不成立，就須要進行調整，紅黑樹有兩種調整操做：post
- 變色（改變節點的顏色）
- 旋轉（左旋轉和右旋轉）
- 左旋轉示意圖（對節點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方法：spa
public V put(K key, V value) {
Entry<K,V> t = root;
//若是根節點是null，直接插入
if (t == 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插入新節點以後的調整函數（重點）：3d
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);
//while循環繼續對祖父進行調整
x = parentOf(parentOf(x));
} 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指向父親節點
x = parentOf(x);
//對x進行左旋轉，把紅色節點移到左邊
rotateLeft(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;
}
複製代碼
示例:code
如下圖紅黑樹爲例 cdn
如今咱們要增長一個節點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);
}
// p沒有孩子節點，而且沒有父親節點，則p是根節點，直接刪除
else if (p.parent == null) {
root = null;
}
// p沒有孩子節點，而且不是根節點，若是是紅色，直接刪除，若是是黑色，則須要進行調整
else {
if (p.color == BLACK)
fixAfterDeletion(p);
//調整完以後把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;
}
}
}
複製代碼
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);
}
//兄弟節點不能直接變紅的狀況下，即情景3
else {
/** * 若是兄弟節點的左孩子是紅色，右孩子是黑色 * 兄弟節點的左孩子變黑，兄弟節點變紅，對兄弟節點右旋轉，把紅色節點轉移到右分支 */
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;
}
}
// x節點是其父節點的右孩子，調整方法和上面的對稱。
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);
}
複製代碼
示例:
- 刪除的節點只有一個子節點（刪除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;
}
複製代碼
由於繼承者節點沒有左孩子節點，因此這個問題又變成了刪除一個孩子節點或者無孩子節點的問題。（參照上面） OK，至此紅黑樹的分析就結束了，但願你們給予意見！
關注微信公衆號，可查閱更多文章
相關文章
- 1. JAVA集合：TreeMap紅黑樹深度解析
- 2. 死磕 java集合之TreeMap源碼分析（二）——紅黑樹全解析
- 3. 死磕 java集合之TreeMap源碼分析（一）——紅黑樹全解析
- 4. 死磕 java集合之TreeMap源碼分析（三）——紅黑樹全解析
- 5. 死磕 java集合之TreeMap源碼分析（四）——紅黑樹全解析
- 6. 紅黑樹、TreeMap、TreeSet
- 7. Java集合（3）一 紅黑樹、TreeMap與TreeSet（上）
- 8. Java集合（4）一 紅黑樹、TreeMap與TreeSet（下）
- 9. 結合 TreeMap 源碼分析紅黑樹在 java 中的實現
- 10. TreeMap（紅黑樹）源碼分析
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • TCP滑動窗口機制深度剖析 - TCP/IP教程
- • 算法總結-深度優先算法
- • ☆技術問答集錦（13）Java Instrument原理
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. JAVA集合：TreeMap紅黑樹深度解析
- 2. 死磕 java集合之TreeMap源碼分析（二）——紅黑樹全解析
- 3. 死磕 java集合之TreeMap源碼分析（一）——紅黑樹全解析
- 4. 死磕 java集合之TreeMap源碼分析（三）——紅黑樹全解析
- 5. 死磕 java集合之TreeMap源碼分析（四）——紅黑樹全解析
- 6. 紅黑樹、TreeMap、TreeSet
- 7. Java集合（3）一 紅黑樹、TreeMap與TreeSet（上）
- 8. Java集合（4）一 紅黑樹、TreeMap與TreeSet（下）
- 9. 結合 TreeMap 源碼分析紅黑樹在 java 中的實現
- 10. TreeMap（紅黑樹）源碼分析