給jdk寫註釋系列之jdk1.6容器(7)-TreeMap源碼解析
TreeMap是基於紅黑樹結構實現的一種Map，要分析TreeMap的實現首先就要對紅黑樹有所瞭解。
要了解什麼是紅黑樹，就要了解它的存在主要是爲了解決什麼問題，對比其餘數據結構好比數組，鏈表，Hash表等樹這種結構又有什麼優勢。
1.二叉查詢樹、紅黑樹介紹
如下爲我的理解，有誤請拍磚。。。
下面我儘量用通俗易懂的語言，簡單總結一下數組，鏈表，Hash表以及樹的優缺點。
1.數組，優勢：(1)隨機訪問效率高(根據下標查詢)，(2)搜索效率較高(可以使用折半方法)。缺點：(1)內存連續且固定，存儲效率低。(2)插入和刪除效率低(可能會進行數組拷貝或擴容)。
2.鏈表，優勢：(1)不要求連續內存，內存利用率高，(2)插入和刪除效率高(只須要改變指針指向)。缺點：(1)不支持隨機訪問，(2)搜索效率低(須要遍歷)。
3.Hash表：優勢：(1)搜索效率高，(2)插入和刪除效率較高，缺點：(1)內存利用率低(基於數組)，(2)存在散列衝突。
上面說的話比較囉嗦，再精煉一下：數組查詢好、插入和刪除差且浪費內存；鏈表插入和刪除好、查詢差；Hash表查詢好、插入和刪除也不錯可是浪費內存。
也就是說，查詢好的插入和刪除就差，插入和刪除好的查詢就差，好不容易有一個查詢、插入和刪除都不錯的，可是卻又浪費內存。哎，好苦惱啊，怎麼辦呢，愁死我啦。能不能作到查詢、插入、刪除效率都很高，又不浪費內存呢。答案固然是不能！哎，仍是好愁人，煩死啦。可是能夠作到查詢、插入、刪除效率比較高，又不浪費內存。哇塞，這是什麼東東，這麼牛掰，這就是二叉查詢樹（又叫二叉排序樹，又叫二叉搜索樹）。你說二叉樹這麼好，那有什麼缺點嗎，有！就是算法複雜。
那麼什麼是二叉查找樹呢，它又有哪些特色呢？（如下見於百度百科）
（1）若左子樹不空，則左子樹上全部結點的值均小於它的根結點的值；
（2）若右子樹不空，則右子樹上全部結點的值均大於它的根結點的值；
（3）左、右子樹也分別爲二叉查找樹；
（4）沒有鍵值相等的節點。
按照二叉查找樹存儲的數據，對元素的搜索效率是很是高的，好比上圖中若是要查找值爲48的節點，只須要遍歷4個節點就能完成。理論上，一顆平衡的二叉查找樹的任意節點平均查找效率爲樹的高度h，即O(lgn)。可是若是二叉查找樹的失去平衡（元素全在一側），搜索效率就退化爲O(n)，所以二叉查找樹的平衡是搜索效率的關鍵所在。而
紅黑樹就是靠紅黑規則來維持二叉查找樹的平衡性。
（一顆失去平衡的二叉樹）
簡單用代碼描述上面的二叉查找樹，試試看：
1 public class BinaryTree { 2 3 // 二叉樹的根節點 4 public TreeNode rootNode ; 5 // 記錄搜索深度 6 public int count; 7 8 /** 9 * 利用傳入一個數組來創建二叉樹 10 */ 11 public BinaryTree(int[] data) { 12 for (int i = 0; i < data. length; i++) { 13 addNodeToTree(data[i]); 14 } 15 } 16 17 /** 18 * 將指定的值加入到二叉樹中適當的節點 19 */ 20 private void addNodeToTree(int value) { 21 TreeNode currentNode = rootNode; 22 // 創建樹根 23 if (rootNode == null) { 24 rootNode = new TreeNode(value); 25 return; 26 } 27 28 // 創建二叉樹 29 while (true) { 30 // 新增的value比節點的value小，則在左子樹 31 if (value < currentNode.value ) { 32 if (currentNode.leftNode == null) { 33 currentNode. leftNode = new TreeNode(value); 34 return; 35 } else { 36 currentNode = currentNode. leftNode; 37 } 38 } else { // 新增的value比節點的value大，在右子樹 39 if (currentNode.rightNode == null) { 40 currentNode. rightNode = new TreeNode(value); 41 return; 42 } else { 43 currentNode = currentNode. rightNode; 44 } 45 } 46 } 47 } 48 49 /** 50 * 中序遍歷(左子樹 -樹根- 右子樹) 51 */ 52 public void inOrder(TreeNode node) { 53 if (node != null) { 54 inOrder(node. leftNode); 55 System. out.print("[" + node.value + "]"); 56 inOrder(node. rightNode); 57 } 58 } 59 60 /** 61 * 前序遍歷(樹根 -左子樹- 右子樹) 62 */ 63 public void preOrder(TreeNode node) { 64 if (node != null) { 65 System. out.print("[" + node.value + "]"); 66 preOrder(node. leftNode); 67 preOrder(node. rightNode); 68 } 69 } 70 71 /** 72 * 後序遍歷(左子樹 -右子樹- 樹根) 73 */ 74 public void postOrder(TreeNode node) { 75 if (node != null) { 76 postOrder(node. leftNode); 77 postOrder(node. rightNode); 78 System. out.print("[" + node.value + "]"); 79 } 80 } 81 82 /** 83 * 從二叉樹中查找指定value 84 */ 85 public boolean findTree(TreeNode node, int value) { 86 if (node == null) { 87 System. out.println("共搜索" + count + "次"); 88 return false; 89 } else if (node.value == value) { 90 System. out.println("共搜索" + count + "次"); 91 return true; 92 } else if (value < node.value) { 93 count++; 94 return findTree(node.leftNode , value); 95 } else { 96 count++; 97 return findTree(node.rightNode , value); 98 } 99 } 100 101 /** 102 * 利用中序遍歷進行排序 103 */ 104 public void sort() { 105 this.inOrder(rootNode ); 106 } 107 108 class TreeNode { 109 int value ; 110 TreeNode leftNode; 111 TreeNode rightNode; 112 113 public TreeNode(int value) { 114 this.value = value; 115 this.leftNode = null; 116 this.rightNode = null; 117 } 118 } 119 120 public static void main(String[] args) { 121 int[] content = { 50, 35, 27, 45, 40, 48, 78, 56, 90 }; 122 123 BinaryTree tree = new BinaryTree(content); 124 System. out.println("前序遍歷:" ); 125 tree.preOrder(tree. rootNode); 126 System. out.println("\n中序遍歷:" ); 127 tree.inOrder(tree. rootNode); 128 System. out.println("\n後序遍歷:" ); 129 tree.postOrder(tree. rootNode); 130 131 System. out.println("\n\n開始搜索:" ); 132 boolean isFind = tree.findTree(tree.rootNode, 48); 133 System. out.println("是否搜索到" + 48 + ":" + isFind); 134 135 System. out.println("\n進行排序:" ); 136 tree.sort(); 137 } 138 }
看下運行結果：
1 前序遍歷: 2 [50][35][27][45][40][48][78][56][90] 3 中序遍歷: 4 [27][35][40][45][48][50][56][78][90] 5 後序遍歷: 6 [27][40][48][45][35][56][90][78][50] 7 8 開始搜索: 9 共搜索3次 10 是否搜索到48:true 11 12 進行排序: 13 [27][35][40][45][48][50][56][78][90]
經過上面代碼是否是對二叉查詢樹有所認識呢，那麼，紅黑樹的紅黑規則究竟是什麼呢？
（1）節點是紅色或黑色。
（2）根節點是黑色。
（3）每一個葉節點（NIL節點，空節點）是黑色的。
（4）每一個紅色節點的兩個子節點都是黑色。(從每一個葉子到根的全部路徑上不能有兩個連續的紅色節點)
（5）從任一節點到其每一個葉子的全部路徑都包含相同數目的黑色節點。
上面的規則前4條都好理解，第5條規則究竟是什麼狀況，下面簡單解釋下，好比圖中紅8到1左邊的葉子節點的路徑包含兩個黑色節點，到6下面的葉子節點的路徑也包含兩個黑色節點。
可是在在添加或刪除節點後，紅黑樹就發生了變化，可能再也不知足上面的5個特性，爲了保持紅黑樹的以上特性，就有了三個動做：左旋、右旋、着色。
下面來看下什麼是紅黑樹的左旋和右旋：
對x進行左旋，意味着"將x變成一個左節點"。
對y進行右旋，意味着"將y變成一個右節點"。
若是仍是沒看明白，下面找了兩張左旋和右旋的動態圖（
http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html）：
ok，對二叉樹、紅黑樹的概念有所瞭解後，咱們來看下紅黑樹的兩個主要邏輯添加和刪除，看看TreeMap是怎麼實現的。
2.TreeMap的底層實現
首先來看下TreeMap的定義：
1 public class TreeMap<K,V> 2 extends AbstractMap<K,V> 3 implements NavigableMap<K,V>, Cloneable, java.io.Serializable
能夠看到TreeMap繼承了AbstractMap抽象類，並實現NavigableMap、Cloneable、Serializable接口。NavigableMap接口擴展了SortedMap，主要是提供了給定搜索目標返回最接近匹配項的導航方法。這個不是咱們今天的重點，這裏不作分析了。
下面再看下TreeMap的底層存儲相關定義：
1 // 比較器 2 private final Comparator<? super K> comparator; 3 4 // 紅黑樹根節點 5 private transient Entry<K,V> root = null; 6 7 // 集合元素數量 8 private transient int size = 0; 9 10 // "fail-fast"集合修改記錄 11 private transient int modCount = 0;
這裏的Comparator是一個比較器，這裏不詳細講解，後面會單獨進行分析，這裏只要明白，一個類實現了Comparator接口並重寫其compare方法，就能進行比較大小。Entry是樹的節點類，咱們來看一下Entry的定義：html
1 static final class Entry<K,V> implements Map.Entry<K,V> { 2 K key; 3 V value; 4 // 左孩子節點 5 Entry<K,V> left = null; 6 // 右孩子節點 7 Entry<K,V> right = null; 8 // 父節點 9 Entry<K,V> parent; 10 // 紅黑樹用來表示節點顏色的屬性，默認爲黑色 11 boolean color = BLACK; 12 13 /** 14 * 用key，value和父節點構造一個Entry，默認爲黑色 15 */ 16 Entry(K key, V value, Entry<K,V> parent) { 17 this.key = key; 18 this.value = value; 19 this.parent = parent; 20 } 21 22 public K getKey() { 23 return key ; 24 } 25 26 public V getValue() { 27 return value ; 28 } 29 30 public V setValue(V value) { 31 V oldValue = this.value ; 32 this.value = value; 33 return oldValue; 34 } 35 36 public boolean equals(Object o) { 37 if (!(o instanceof Map.Entry)) 38 return false; 39 Map.Entry<?,?> e = (Map.Entry<?,?>)o; 40 41 return valEquals( key,e.getKey()) && valEquals( value,e.getValue()); 42 } 43 44 public int hashCode() { 45 int keyHash = (key ==null ? 0 : key.hashCode()); 46 int valueHash = (value ==null ? 0 : value.hashCode()); 47 return keyHash ^ valueHash; 48 } 49 50 public String toString() { 51 return key + "=" + value; 52 } 53 }
Entry類理解起來比較簡單（由於咱們前面看過不少的Entry類了），主要是定義了樹的孩子和父親節點引用，和紅黑顏色屬性，並對equals和hashCode進行重寫，以利於比較是否相等。
3.TreeMap的構造方法
接下來看下TreeMap的構造方法：
1 /** 2 * 默認構造方法，comparator爲空，表明使用key的天然順序來維持TreeMap的順序，這裏要求key必須實現Comparable接口 3 */ 4 public TreeMap() { 5 comparator = null; 6 } 7 8 /** 9 * 用指定的比較器構造一個TreeMap 10 */ 11 public TreeMap(Comparator<? super K> comparator) { 12 this.comparator = comparator; 13 } 14 15 /** 16 * 構造一個指定map的TreeMap，一樣比較器comparator爲空，使用key的天然順序排序 17 */ 18 public TreeMap(Map<? extends K, ? extends V> m) { 19 comparator = null; 20 putAll(m); 21 } 22 23 /** 24 * 構造一個指定SortedMap的TreeMap，根據SortedMap的比較器來來維持TreeMap的順序 25 */ 26 public TreeMap(SortedMap<K, ? extends V> m) { 27 comparator = m.comparator(); 28 try { 29 buildFromSorted(m.size(), m.entrySet().iterator(), null, null); 30 } catch (java.io.IOException cannotHappen) { 31 } catch (ClassNotFoundException cannotHappen) { 32 } 33 }
從構造方法中能夠看出，要建立一個紅黑樹實現的TreeMap必需要有一個用於比較大小的比較器，由於只有可以比較大小才能實現紅黑樹的左孩子<樹根<右孩子的特色。
4.紅黑樹的添加原理及TreeMap的put實現
將一個節點添加到紅黑樹中，一般須要下面幾個步驟：
（1）將紅黑樹當成一顆二叉查找樹，將節點插入。
這一步比較簡單，就上開始咱們本身寫的二叉查找樹的操做同樣，至於爲何能夠這樣插入，是由於紅黑樹自己就是一個二叉查找樹。
（2）將新插入的節點設置爲紅色
有沒有疑問，爲何新插入的節點必定要是紅色的，由於新插入節點爲紅色，不會違背紅黑規則第（5）條，少違背一條就少處理一種狀況。
（3）經過旋轉和着色，使它恢復平衡，從新變成一顆符合規則的紅黑樹。
要想知道怎麼樣進行左旋和右旋，首先就要知道爲何要進行左旋和右旋。
咱們來對比下紅黑樹的規則和新插入節點後的狀況，看下新插入節點會違背哪些規則。
（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是怎麼實現的呢，咱們來看下：
1 public V put(K key, V value) { 2 // 根節點 3 Entry<K,V> t = root; 4 // 若是根節點爲空，則直接建立一個根節點，返回 5 if (t == null) { 6 // TBD: 7 // 5045147: (coll) Adding null to an empty TreeSet should 8 // throw NullPointerException 9 // 10 // compare(key, key); // type check 11 root = new Entry<K,V>(key, value, null); 12 size = 1; 13 modCount++; 14 return null; 15 } 16 // 記錄比較結果 17 int cmp; 18 Entry<K,V> parent; 19 // split comparator and comparable paths 20 // 當前使用的比較器 21 Comparator<? super K> cpr = comparator ; 22 // 若是比較器不爲空，就是用指定的比較器來維護TreeMap的元素順序 23 if (cpr != null) { 24 // do while循環，查找key要插入的位置（也就是新節點的父節點是誰） 25 do { 26 // 記錄上次循環的節點t 27 parent = t; 28 // 比較當前節點的key和新插入的key的大小 29 cmp = cpr.compare(key, t. key); 30 // 新插入的key小的話，則以當前節點的左孩子節點爲新的比較節點 31 if (cmp < 0) 32 t = t. left; 33 // 新插入的key大的話，則以當前節點的右孩子節點爲新的比較節點 34 else if (cmp > 0) 35 t = t. right; 36 else 37 // 若是當前節點的key和新插入的key想的的話，則覆蓋map的value，返回 38 return t.setValue(value); 39 // 只有當t爲null，也就是沒有要比較節點的時候，表明已經找到新節點要插入的位置 40 } while (t != null); 41 } 42 else { 43 // 若是比較器爲空，則使用key做爲比較器進行比較 44 // 這裏要求key不能爲空，而且必須實現Comparable接口 45 if (key == null) 46 throw new NullPointerException(); 47 Comparable<? super K> k = (Comparable<? super K>) key; 48 // 和上面同樣，喜歡查找新節點要插入的位置 49 do { 50 parent = t; 51 cmp = k.compareTo(t. key); 52 if (cmp < 0) 53 t = t. left; 54 else if (cmp > 0) 55 t = t. right; 56 else 57 return t.setValue(value); 58 } while (t != null); 59 } 60 // 找到新節點的父節點後，建立節點對象 61 Entry<K,V> e = new Entry<K,V>(key, value, parent); 62 // 若是新節點key的值小於父節點key的值，則插在父節點的左側 63 if (cmp < 0) 64 parent. left = e; 65 // 若是新節點key的值大於父節點key的值，則插在父節點的右側 66 else 67 parent. right = e; 68 // 插入新的節點後，爲了保持紅黑樹平衡，對紅黑樹進行調整 69 fixAfterInsertion(e); 70 // map元素個數+1 71 size++; 72 modCount++; 73 return null; 74 } 75 76 77 /** 新增節點後對紅黑樹的調整方法 */ 78 private void fixAfterInsertion(Entry<K,V> x) { 79 // 將新插入節點的顏色設置爲紅色 80 x. color = RED; 81 82 // while循環，保證新插入節點x不是根節點或者新插入節點x的父節點不是紅色（這兩種狀況不須要調整） 83 while (x != null && x != root && x. parent.color == RED) { 84 // 若是新插入節點x的父節點是祖父節點的左孩子 85 if (parentOf(x) == leftOf(parentOf (parentOf(x)))) { 86 // 取得新插入節點x的叔叔節點 87 Entry<K,V> y = rightOf(parentOf (parentOf(x))); 88 // 若是新插入x的父節點是紅色-------------------① 89 if (colorOf(y) == RED) { 90 // 將x的父節點設置爲黑色 91 setColor(parentOf (x), BLACK); 92 // 將x的叔叔節點設置爲黑色 93 setColor(y, BLACK); 94 // 將x的祖父節點設置爲紅色 95 setColor(parentOf (parentOf(x)), RED); 96 // 將x指向祖父節點，若是x的祖父節點的父節點是紅色，按照上面的步奏繼續循環 97 x = parentOf(parentOf (x)); 98 } else { 99 // 若是新插入x的叔叔節點是黑色或缺乏，且x的父節點是祖父節點的右孩子-------------------② 100 if (x == rightOf( parentOf(x))) { 101 // 左旋父節點 102 x = parentOf(x); 103 rotateLeft(x); 104 } 105 // 若是新插入x的叔叔節點是黑色或缺乏，且x的父節點是祖父節點的左孩子-------------------③ 106 // 將x的父節點設置爲黑色 107 setColor(parentOf (x), BLACK); 108 // 將x的祖父節點設置爲紅色 109 setColor(parentOf (parentOf(x)), RED); 110 // 右旋x的祖父節點 111 rotateRight( parentOf(parentOf (x))); 112 } 113 } else { // 若是新插入節點x的父節點是祖父節點的右孩子，下面的步奏和上面的類似，只不過左旋右旋的區分，不在細講 114 Entry<K,V> y = leftOf(parentOf (parentOf(x))); 115 if (colorOf(y) == RED) { 116 setColor(parentOf (x), BLACK); 117 setColor(y, BLACK); 118 setColor(parentOf (parentOf(x)), RED); 119 x = parentOf(parentOf (x)); 120 } else { 121 if (x == leftOf( parentOf(x))) { 122 x = parentOf(x); 123 rotateRight(x); 124 } 125 setColor(parentOf (x), BLACK); 126 setColor(parentOf (parentOf(x)), RED); 127 rotateLeft( parentOf(parentOf (x))); 128 } 129 } 130 } 131 // 最後將根節點設置爲黑色，無論當前是否是紅色，反正根節點必須是黑色 132 root.color = BLACK; 133 } 134 135 /** 136 * 對紅黑樹的節點(x)進行左旋轉 137 * 138 * 左旋示意圖(對節點x進行左旋)： 139 * px px 140 * / / 141 * x y 142 * / \ --(左旋)-- / \ 143 * lx y x ry 144 * / \ / \ 145 * ly ry lx ly 146 * 147 */ 148 private void rotateLeft(Entry<K,V> p) { 149 if (p != null) { 150 // 取得要選擇節點p的右孩子 151 Entry<K,V> r = p. right; 152 // "p"和"r的左孩子"的相互指向... 153 // 將"r的左孩子"設爲"p的右孩子" 154 p. right = r.left ; 155 // 若是r的左孩子非空，將"p"設爲"r的左孩子的父親" 156 if (r.left != null) 157 r. left.parent = p; 158 159 // "p的父親"和"r"的相互指向... 160 // 將"p的父親"設爲"y的父親" 161 r. parent = p.parent ; 162 // 若是"p的父親"是空節點，則將r設爲根節點 163 if (p.parent == null) 164 root = r; 165 // 若是p是它父節點的左孩子，則將r設爲"p的父節點的左孩子" 166 else if (p.parent. left == p) 167 p. parent.left = r; 168 else 169 // 若是p是它父節點的左孩子，則將r設爲"p的父節點的左孩子" 170 p. parent.right = r; 171 // "p"和"r"的相互指向... 172 // 將"p"設爲"r的左孩子" 173 r. left = p; 174 // 將"p的父節點"設爲"r" 175 p. parent = r; 176 } 177 } 178 179 180 /** 181 * 對紅黑樹的節點進行右旋轉 182 * 183 * 右旋示意圖(對節點y進行右旋)： 184 * py py 185 * / / 186 * y x 187 * / \ --(右旋)-- / \ 188 * x ry lx y 189 * / \ / \ 190 * lx rx rx ry 191 * 192 */ 193 private void rotateRight(Entry<K,V> p) { 194 if (p != null) { 195 // 取得要選擇節點p的左孩子 196 Entry<K,V> l = p. left; 197 // 將"l的右孩子"設爲"p的左孩子" 198 p. left = l.right ; 199 // 若是"l的右孩子"不爲空的話，將"p"設爲"l的右孩子的父親" 200 if (l.right != null) l. right.parent = p; 201 // 將"p的父親"設爲"l的父親" 202 l. parent = p.parent ; 203 // 若是"p的父親"是空節點，則將l設爲根節點 204 if (p.parent == null) 205 root = l; 206 // 若是p是它父節點的右孩子，則將l設爲"p的父節點的右孩子" 207 else if (p.parent. right == p) 208 p. parent.right = l; 209 //若是p是它父節點的左孩子，將l設爲"p的父節點的左孩子" 210 else p.parent .left = l; 211 // 將"p"設爲"l的右孩子" 212 l. right = p; 213 // 將"l"設爲"p父節點" 214 p. parent = l; 215 } 216 }
單純的看代碼和註釋，絕對會發出，cha這是什麼亂七八糟的，任誰也看不懂，因此必定要結合上面的圖解，不懂了就看看圖，而後動手畫一下。若是你告訴我，仍是沒有懂，沒問題能夠理解，這裏有一位大神錄製的紅黑樹增長元素視頻動畫，來吧，
http://v.youku.com/v_show/id_XNjI4NzgxMjA4.html（視頻不是我錄得，尊重版權，向大神致敬）。
5.紅黑樹的刪除原理及TreeMap的remove實現
相比添加，紅黑樹的刪除顯得更加複雜了。看下紅黑樹的刪除須要哪幾個步奏：
（1）將紅黑樹當成一顆二叉查找樹，將節點刪除。
（2）經過旋轉和着色，使它恢復平衡，從新變成一顆符合規則的紅黑樹。
刪除節點的關鍵是：
（1）若是刪除的是紅色節點，不會違背紅黑樹的規則。
（2）
若是刪除的是黑色節點，那麼這個路徑上就少了一個黑色節點，則違背了紅黑樹的規則。
來看下紅黑樹刪除節點會有哪幾種狀況：
（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的代碼是怎麼實現的：
1 public V remove(Object key) { 2 // 根據key查找到對應的節點對象 3 Entry<K,V> p = getEntry(key); 4 if (p == null) 5 return null; 6 7 // 記錄key對應的value，供返回使用 8 V oldValue = p. value; 9 // 刪除節點 10 deleteEntry(p); 11 return oldValue; 12 } 13 14 15 private void deleteEntry(Entry<K,V> p) { 16 modCount++; 17 // map容器的元素個數減一 18 size--; 19 20 // If strictly internal, copy successor's element to p and then make p 21 // point to successor. 22 // 若是被刪除的節點p的左孩子和右孩子都不爲空，則查找其替代節點-----------這裏表示要刪除的節點有兩個孩子（3） 23 if (p.left != null && p. right != null) { 24 // 查找p的替代節點 25 Entry<K,V> s = successor (p); 26 p. key = s.key ; 27 p. value = s.value ; 28 // 將p指向替代節點，※※※※※※今後以後的p再也不是原先要刪除的節點p，而是替代者p（就是圖解裏面講到的M） ※※※※※※ 29 p = s; 30 } // p has 2 children 31 32 // Start fixup at replacement node, if it exists. 33 // replacement爲替代節點p的繼承者（就是圖解裏面講到的N），p的左孩子存在則用p的左孩子替代，不然用p的右孩子 34 Entry<K,V> replacement = (p. left != null ? p.left : p. right); 35 36 if (replacement != null) { // 若是上面的if有兩個孩子不經過--------------這裏表示要刪除的節點只有一個孩子（2） 37 // Link replacement to parent 38 // 將p的父節點拷貝給替代節點 39 replacement. parent = p.parent ; 40 // 若是替代節點p的父節點爲空，也就是p爲跟節點，則將replacement設置爲根節點 41 if (p.parent == null) 42 root = replacement; 43 // 若是替代節點p是其父節點的左孩子，則將replacement設置爲其父節點的左孩子 44 else if (p == p.parent. left) 45 p. parent.left = replacement; 46 // 若是替代節點p是其父節點的左孩子，則將replacement設置爲其父節點的右孩子 47 else 48 p. parent.right = replacement; 49 50 // Null out links so they are OK to use by fixAfterDeletion. 51 // 將替代節點p的left、right、parent的指針都指向空，即解除先後引用關係（至關於將p從樹種摘除），使得gc能夠回收 52 p. left = p.right = p.parent = null; 53 54 // Fix replacement 55 // 若是替代節點p的顏色是黑色，則須要調整紅黑樹以保持其平衡 56 if (p.color == BLACK) 57 fixAfterDeletion(replacement); 58 } else if (p.parent == null) { // return if we are the only node. 59 // 若是要替代節點p沒有父節點，表明p爲根節點，直接刪除便可 60 root = null; 61 } else { // No children. Use self as phantom replacement and unlink. 62 // 判斷進入這裏說明替代節點p沒有孩子--------------這裏表示沒有孩子則直接刪除（1） 63 // 若是p的顏色是黑色，則調整紅黑樹 64 if (p.color == BLACK) 65 fixAfterDeletion(p); 66 // 下面刪除替代節點p 67 if (p.parent != null) { 68 // 解除p的父節點對p的引用 69 if (p == p.parent .left) 70 p. parent.left = null; 71 else if (p == p.parent. right) 72 p. parent.right = null; 73 // 解除p對p父節點的引用 74 p. parent = null; 75 } 76 } 77 } 78 79 /** 80 * 查找要刪除節點的替代節點 81 */ 82 static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) { 83 if (t == null) 84 return null; 85 // 查找右子樹的最左孩子 86 else if (t.right != null) { 87 Entry<K,V> p = t. right; 88 while (p.left != null) 89 p = p. left; 90 return p; 91 } else { // 查找左子樹的最右孩子 92 Entry<K,V> p = t. parent; 93 Entry<K,V> ch = t; 94 while (p != null && ch == p. right) { 95 ch = p; 96 p = p. parent; 97 } 98 return p; 99 } 100 } 101 102 /** From CLR */ 103 private void fixAfterDeletion(Entry<K,V> x) { 104 // while循環，保證要刪除節點x不是跟節點，而且是黑色（根節點和紅色不須要調整） 105 while (x != root && colorOf (x) == BLACK) { 106 // 若是要刪除節點x是其父親的左孩子 107 if (x == leftOf( parentOf(x))) { 108 // 取出要刪除節點x的兄弟節點 109 Entry<K,V> sib = rightOf(parentOf (x)); 110 111 // 若是刪除節點x的兄弟節點是紅色---------------------------① 112 if (colorOf(sib) == RED) { 113 // 將x的兄弟節點顏色設置爲黑色 114 setColor(sib, BLACK); 115 // 將x的父節點顏色設置爲紅色 116 setColor(parentOf (x), RED); 117 // 左旋x的父節點 118 rotateLeft( parentOf(x)); 119 // 將sib從新指向旋轉後x的兄弟節點 ，進入else的步奏③ 120 sib = rightOf(parentOf (x)); 121 } 122 123 // 若是x的兄弟節點的兩個孩子都是黑色-------------------------③ 124 if (colorOf(leftOf(sib)) == BLACK && 125 colorOf(rightOf (sib)) == BLACK) { 126 // 將兄弟節點的顏色設置爲紅色 127 setColor(sib, RED); 128 // 將x的父節點指向x，若是x的父節點是黑色，須要將x的父節點成天看作一個節點繼續調整-------------------------② 129 x = parentOf(x); 130 } else { 131 // 若是x的兄弟節點右孩子是黑色，左孩子是紅色-------------------------④ 132 if (colorOf(rightOf(sib)) == BLACK) { 133 // 將x的兄弟節點的左孩子設置爲黑色 134 setColor(leftOf (sib), BLACK); 135 // 將x的兄弟節點設置爲紅色 136 setColor(sib, RED); 137 // 右旋x的兄弟節點 138 rotateRight(sib); 139 // 將sib從新指向旋轉後x的兄弟節點，進入步奏⑤ 140 sib = rightOf(parentOf (x)); 141 } 142 // 若是x的兄弟節點右孩子是紅色-------------------------⑤ 143 setColor(sib, colorOf (parentOf(x))); 144 // 將x的父節點設置爲黑色 145 setColor(parentOf (x), BLACK); 146 // 將x的兄弟節點的右孩子設置爲黑色 147 setColor(rightOf (sib), BLACK); 148 // 左旋x的父節點 149 rotateLeft( parentOf(x)); 150 // 達到平衡，將x指向root，退出循環 151 x = root; 152 } 153 } else { // symmetric // 若是要刪除節點x是其父親的右孩子，和上面狀況同樣，這裏再也不細講 154 Entry<K,V> sib = leftOf(parentOf (x)); 155 156 if (colorOf(sib) == RED) { 157 setColor(sib, BLACK); 158 setColor(parentOf (x), RED); 159 rotateRight( parentOf(x)); 160 sib = leftOf(parentOf (x)); 161 } 162 163 if (colorOf(rightOf(sib)) == BLACK && 164 colorOf(leftOf (sib)) == BLACK) { 165 setColor(sib, RED); 166 x = parentOf(x); 167 } else { 168 if (colorOf(leftOf(sib)) == BLACK) { 169 setColor(rightOf (sib), BLACK); 170 setColor(sib, RED); 171 rotateLeft(sib); 172 sib = leftOf(parentOf (x)); 173 } 174 setColor(sib, colorOf (parentOf(x))); 175 setColor(parentOf (x), BLACK); 176 setColor(leftOf (sib), BLACK); 177 rotateRight( parentOf(x)); 178 x = root; 179 } 180 } 181 } 182 183 setColor(x, BLACK); 184 }
刪除相對來講更加複雜，仍是那句話必定要對照着圖解看代碼，不然是讀不懂的，別問我是怎麼看懂得，我n天不看再看代碼也不知道123了。
終於看完了紅黑樹的增長和刪除，下面來看個稍微簡單的查詢：
6.紅黑樹的查詢
1 public V get(Object key) { 2 Entry<K,V> p = getEntry(key); 3 return (p==null ? null : p. value); 4 } 5 6 final Entry<K,V> getEntry(Object key) { 7 // Offload comparator-based version for sake of performance 8 if (comparator != null) 9 // 若是比較器爲空，只是用key做爲比較器查詢 10 return getEntryUsingComparator(key); 11 if (key == null) 12 throw new NullPointerException(); 13 Comparable<? super K> k = (Comparable<? super K>) key; 14 // 取得root節點 15 Entry<K,V> p = root; 16 // 從root節點開始查找，根據比較器判斷是在左子樹仍是右子樹 17 while (p != null) { 18 int cmp = k.compareTo(p.key ); 19 if (cmp < 0) 20 p = p. left; 21 else if (cmp > 0) 22 p = p. right; 23 else 24 return p; 25 } 26 return null; 27 } 28 29 final Entry<K,V> getEntryUsingComparator(Object key) { 30 K k = (K) key; 31 Comparator<? super K> cpr = comparator ; 32 if (cpr != null) { 33 Entry<K,V> p = root; 34 while (p != null) { 35 int cmp = cpr.compare(k, p.key ); 36 if (cmp < 0) 37 p = p. left; 38 else if (cmp > 0) 39 p = p. right; 40 else 41 return p; 42 } 43 } 44 return null; 45 }
查詢看起來真的是so easy。。。
6.TreeMap對NavigableMap接口的實現
TreeMap對NavigableMap接口的實現的內容，不做爲這裏的重點，這些內容會和TreeSet一塊兒分析，TreeSet見。
到此TreeMap就分析完了，其實大部分時間都在整理紅黑樹，在數據結構中樹是比較難懂的一個，其算法也比較複雜，對於樹的理解必定要多看圖畫圖，要明白這麼作是爲了解決什麼問題，這麼作又有什麼好處，固然看一遍看不懂就要多看幾遍了。什麼你問我平時工做中會用到樹嗎？那真的要看你作的什麼性質的工做，若是是web、客戶端開發，調用api就能夠了對吧，若是是從事底層開發，好比文件系統，存儲系統，緩存等工做必須是須要的。固然就算用不到，理解了也是有益無害的。
紅黑樹&TreeMap 完！
參見：
參考資料：
相關文章
- 1. 給jdk寫註釋系列之jdk1.6容器(11)-Queue之ArrayDeque源碼解析
- 2. 給jdk寫註釋系列之jdk1.6容器(2)-LinkedList源碼解析
- 3. 給jdk寫註釋系列之jdk1.6容器(10)-Stack&Vector源碼解析
- 4. 給jdk寫註釋系列之jdk1.6容器(8)-TreeSet&NavigableMap&NavigableSet源碼解析
- 5. 給jdk寫註釋系列之jdk1.6容器(12)-PriorityQueue源碼解析
- 6. 給jdk寫註釋系列之jdk1.6容器(4)-HashMap源碼解析
- 7. 給jdk寫註釋系列之jdk1.6容器(5)-LinkedHashMap源碼解析
- 8. 給jdk寫註釋系列之jdk1.6容器(1)-ArrayList源碼解析
- 9. 給jdk寫註釋系列之jdk1.6容器(6)-HashSet源碼解析&Map迭代器
- 10. 給jdk寫註釋系列之jdk1.6容器(3)-Iterator設計模式
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • R 註釋 - R 語言教程
- • Docker容器實戰(七) - 容器眼光下的文件系統
- • 互聯網組織的未來：剖析GitHub員工的任性之源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 給jdk寫註釋系列之jdk1.6容器(11)-Queue之ArrayDeque源碼解析
- 2. 給jdk寫註釋系列之jdk1.6容器(2)-LinkedList源碼解析
- 3. 給jdk寫註釋系列之jdk1.6容器(10)-Stack&Vector源碼解析
- 4. 給jdk寫註釋系列之jdk1.6容器(8)-TreeSet&NavigableMap&NavigableSet源碼解析
- 5. 給jdk寫註釋系列之jdk1.6容器(12)-PriorityQueue源碼解析
- 6. 給jdk寫註釋系列之jdk1.6容器(4)-HashMap源碼解析
- 7. 給jdk寫註釋系列之jdk1.6容器(5)-LinkedHashMap源碼解析
- 8. 給jdk寫註釋系列之jdk1.6容器(1)-ArrayList源碼解析
- 9. 給jdk寫註釋系列之jdk1.6容器(6)-HashSet源碼解析&Map迭代器
- 10. 給jdk寫註釋系列之jdk1.6容器(3)-Iterator設計模式