public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable {
// 使用 NavigableMap 的 key 來保存 Set 集合的元素
private transient NavigableMap<E, Object> m;
// 使用一個 PRESENT 作爲 Map 集合的所有 value。
private static final Object PRESENT = new Object();
// 包訪問權限的構造器，以指定的 NavigableMap 對象創建 Set 集合
TreeSet(NavigableMap<E, Object> m) {
this.m = m;
}
public TreeSet() // ①
{
// 以自然排序方式創建一個新的 TreeMap，
// 根據該 TreeSet 創建一個 TreeSet，
// 使用該 TreeMap 的 key 來保存 Set 集合的元素
this(new TreeMap<E, Object>());
}
public TreeSet(Comparator<? super E> comparator) // ②
{
// 以定製排序方式創建一個新的 TreeMap，
// 根據該 TreeSet 創建一個 TreeSet，
// 使用該 TreeMap 的 key 來保存 Set 集合的元素
this(new TreeMap<E, Object>(comparator));
}
public TreeSet(Collection<? extends E> c) {
// 調用①號構造器創建一個 TreeSet，底層以 TreeMap 保存集合元素
this();
// 向 TreeSet 中添加 Collection 集合 c 裏的所有元素
addAll(c);
}
public TreeSet(SortedSet<E> s) {
// 調用②號構造器創建一個 TreeSet，底層以 TreeMap 保存集合元素
this(s.comparator());
// 向 TreeSet 中添加 SortedSet 集合 s 裏的所有元素
addAll(s);
}
//TreeSet 的其他方法都只是直接調用 TreeMap 的方法來提供實現
public boolean addAll(Collection<? extends E> c) {
if (m.size() == 0 && c.size() > 0 &&
c instanceof SortedSet &&
m instanceof TreeMap) {
// 把 c 集合強制轉換爲 SortedSet 集合
SortedSet<? extends E> set = (SortedSet<? extends E>) c;
// 把 m 集合強制轉換爲 TreeMap 集合
TreeMap<E, Object> map = (TreeMap<E, Object>) m;
Comparator<? super E> cc = (Comparator<? super E>) set.comparator();
Comparator<? super E> mc = map.comparator();
// 如果 cc 和 mc 兩個 Comparator 相等
if (cc == mc || (cc != null && cc.equals(mc))) {
// 把 Collection 中所有元素添加成 TreeMap 集合的 key
map.addAllForTreeSet(set, PRESENT);
return true;
}
}
// 直接調用父類的 addAll() 方法來實現
return super.addAll(c);
}
}
public class TreeMapTest
{
public static void main(String[] args)
{
TreeMap<String , Double> map =
new TreeMap<String , Double>();
map.put("ccc" , 89.0);
map.put("aaa" , 80.0);
map.put("zzz" , 80.0);
map.put("bbb" , 89.0);
System.out.println(map);
}
}
{aaa=80.0, bbb=89.0, ccc=89.0, zzz=80.0}
紅黑樹
-
若它的左子樹不空，則左子樹上所有節點的值均小於它的根節點的值；
-
若它的右子樹不空，則右子樹上所有節點的值均大於它的根節點的值；
-
它的左、右子樹也分別爲排序二叉樹。
`{2，3，4，8，9，9，10，13，15，18}`
-
以根節點當前節點開始搜索。
-
拿新節點的值和當前節點的值比較。
-
如果新節點的值更大，則以當前節點的右子節點作爲新的當前節點；如果新節點的值更小，則以當前節點的左子節點作爲新的當前節點。
-
重複 2、3 兩個步驟，直到搜索到合適的葉子節點爲止。
-
將新節點添加爲第 4 步找到的葉子節點的子節點；如果新節點更大，則添加爲右子節點；否則添加爲左子節點。
public V put(K key, V value)
{
// 先以 t 保存鏈表的 root 節點
Entry<K,V> t = root;
// 如果 t==null，表明是一個空鏈表，即該 TreeMap 裏沒有任何 Entry
if (t == null)
{
// 將新的 key-value 創建一個 Entry，並將該 Entry 作爲 root
root = new Entry<K,V>(key, value, null);
// 設置該 Map 集合的 size 爲 1，代表包含一個 Entry
size = 1;
// 記錄修改次數爲 1
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
Comparator<? super K> cpr = comparator;
// 如果比較器 cpr 不爲 null，即表明採用定製排序
if (cpr != null)
{
do {
// 使用 parent 上次循環後的 t 所引用的 Entry
parent = t;
// 拿新插入 key 和 t 的 key 進行比較
cmp = cpr.compare(key, t.key);
// 如果新插入的 key 小於 t 的 key，t 等於 t 的左邊節點
if (cmp < 0)
t = t.left;
// 如果新插入的 key 大於 t 的 key，t 等於 t 的右邊節點
else if (cmp > 0)
t = t.right;
// 如果兩個 key 相等，新的 value 覆蓋原有的 value，
// 並返回原有的 value
else
return t.setValue(value);
} while (t != null);
}
else
{
if (key == null)
throw new NullPointerException();
Comparable<? super K> k = (Comparable<? super K>) key;
do {
// 使用 parent 上次循環後的 t 所引用的 Entry
parent = t;
// 拿新插入 key 和 t 的 key 進行比較
cmp = k.compareTo(t.key);
// 如果新插入的 key 小於 t 的 key，t 等於 t 的左邊節點
if (cmp < 0)
t = t.left;
// 如果新插入的 key 大於 t 的 key，t 等於 t 的右邊節點
else if (cmp > 0)
t = t.right;
// 如果兩個 key 相等，新的 value 覆蓋原有的 value，
// 並返回原有的 value
else
return t.setValue(value);
} while (t != null);
}
// 將新插入的節點作爲 parent 節點的子節點
Entry<K,V> e = new Entry<K,V>(key, value, parent);
// 如果新插入 key 小於 parent 的 key，則 e 作爲 parent 的左子節點
if (cmp < 0)
parent.left = e;
// 如果新插入 key 小於 parent 的 key，則 e 作爲 parent 的右子節點
else
parent.right = e;
// 修復紅黑樹
fixAfterInsertion(e); // ①
size++;
modCount++;
return null;
}
-
將 pL 設爲 p 的父節點 q 的左或右子節點（取決於 p 是其父節點 q 的左、右子節點），將 pR 設爲 p 節點的中序前趨節點 s 的右子節點（s 是 pL 最右下的節點，也就是 pL 子樹中最大的節點）。
-
以 p 節點的中序前趨或後繼替代 p 所指節點，然後再從原排序二叉樹中刪去中序前趨或後繼節點即可。（也就是用大於 p 的最小節點或小於 p 的最大節點代替 p 節點即可）。
private void deleteEntry(Entry<K,V> p)
{
modCount++;
size--;
// 如果被刪除節點的左子樹、右子樹都不爲空
if (p.left != null && p.right != null)
{
// 用 p 節點的中序後繼節點代替 p 節點
Entry<K,V> s = successor (p);
p.key = s.key;
p.value = s.value;
p = s;
}
// 如果 p 節點的左節點存在，replacement 代表左節點；否則代表右節點。
Entry<K,V> replacement = (p.left != null ? p.left : p.right);
if (replacement != null)
{
replacement.parent = p.parent;
// 如果 p 沒有父節點，則 replacemment 變成父節點
if (p.parent == null)
root = replacement;
// 如果 p 節點是其父節點的左子節點
else if (p == p.parent.left)
p.parent.left = replacement;
// 如果 p 節點是其父節點的右子節點
else
p.parent.right = replacement;
p.left = p.right = p.parent = null;
// 修復紅黑樹
if (p.color == BLACK)
fixAfterDeletion(replacement); // ①
}
// 如果 p 節點沒有父節點
else if (p.parent == null)
{
root = null;
}
else
{
if (p.color == BLACK)
// 修復紅黑樹
fixAfterDeletion(p); // ②
if (p.parent != null)
{
// 如果 p 是其父節點的左子節點
if (p == p.parent.left)
p.parent.left = null;
// 如果 p 是其父節點的右子節點
else if (p == p.parent.right)
p.parent.right = null;
p.parent = null;
}
}
}
Java 實現的紅黑樹
-
性質 1：每個節點要麼是紅色，要麼是黑色。
-
性質 2：根節點永遠是黑色的。
-
性質 3：所有的葉節點都是空節點（即 null），並且是黑色的。
-
性質 4：每個紅色節點的兩個子節點都是黑色。（從每個葉子到根的路徑上不會有兩個連續的紅色節點）
-
性質 5：從任一節點到其子樹中每個葉子節點的路徑都包含相同數量的黑色節點。
紅黑樹和平衡二叉樹
插入後的修復
// 插入節點後修復紅黑樹
private void fixAfterInsertion(Entry<K,V> x)
{
x.color = RED;
// 直到 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 = parentOf(parentOf(x));
}
// 如果 x 的父節點的兄弟節點是黑色
else
{
// 如果 x 是其父節點的右子節點
if (x == rightOf(parentOf(x)))
{
// 將 x 的父節點設爲 x
x = parentOf(x);
rotateLeft(x);
}
// 把 x 的父節點設爲黑色
setColor(parentOf(x), BLACK);
// 把 x 的父節點的父節點設爲紅色
setColor(parentOf(parentOf(x)), RED);
rotateRight(parentOf(parentOf(x)));
}
}
// 如果 x 的父節點是其父節點的右子節點
else
{
// 獲取 x 的父節點的兄弟節點
Entry<K,V> y = leftOf(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));
}
// 如果 x 的父節點的兄弟節點是黑色
else
{
// 如果 x 是其父節點的左子節點
if (x == leftOf(parentOf(x)))
{
// 將 x 的父節點設爲 x
x = parentOf(x);
rotateRight(x);
}
// 把 x 的父節點設爲黑色
setColor(parentOf(x), BLACK);
// 把 x 的父節點的父節點設爲紅色
setColor(parentOf(parentOf(x)), RED);
rotateLeft(parentOf(parentOf(x)));
}
}
}
// 將根節點設爲黑色
root.color = BLACK;
}
// 刪除節點後修復紅黑樹
private void fixAfterDeletion(Entry<K,V> x)
{
// 直到 x 不是根節點，且 x 的顏色是黑色
while (x != root && colorOf(x) == BLACK)
{
// 如果 x 是其父節點的左子節點
if (x == leftOf(parentOf(x)))
{
// 獲取 x 節點的兄弟節點
Entry<K,V> sib = rightOf(parentOf(x));
// 如果 sib 節點是紅色
if (colorOf(sib) == RED)
{
// 將 sib 節點設爲黑色
setColor(sib, BLACK);
// 將 x 的父節點設爲紅色
setColor(parentOf(x), RED);
rotateLeft(parentOf(x));
// 再次將 sib 設爲 x 的父節點的右子節點
sib = rightOf(parentOf(x));
}
// 如果 sib 的兩個子節點都是黑色
if (colorOf(leftOf(sib)) == BLACK
&& colorOf(rightOf(sib)) == BLACK)
{
// 將 sib 設爲紅色
setColor(sib, RED);
// 讓 x 等於 x 的父節點
x = parentOf(x);
}
else
{
// 如果 sib 的只有右子節點是黑色
if (colorOf(rightOf(sib)) == BLACK)
{
// 將 sib 的左子節點也設爲黑色
setColor(leftOf(sib), BLACK);
// 將 sib 設爲紅色
setColor(sib, RED);
rotateRight(sib);
sib = rightOf(parentOf(x));
}
// 設置 sib 的顏色與 x 的父節點的顏色相同
setColor(sib, colorOf(parentOf(x)));
// 將 x 的父節點設爲黑色
setColor(parentOf(x), BLACK);
// 將 sib 的右子節點設爲黑色
setColor(rightOf(sib), BLACK);
rotateLeft(parentOf(x));
x = root;
}
}
// 如果 x 是其父節點的右子節點
else
{
// 獲取 x 節點的兄弟節點
Entry<K,V> sib = leftOf(parentOf(x));
// 如果 sib 的顏色是紅色
if (colorOf(sib) == RED)
{
// 將 sib 的顏色設爲黑色
setColor(sib, BLACK);
// 將 sib 的父節點設爲紅色
setColor(parentOf(x), RED);
rotateRight(parentOf(x));
sib = leftOf(parentOf(x));
}
// 如果 sib 的兩個子節點都是黑色
if (colorOf(rightOf(sib)) == BLACK
&& colorOf(leftOf(sib)) == BLACK)
{
// 將 sib 設爲紅色
setColor(sib, RED);
// 讓 x 等於 x 的父節點
x = parentOf(x);
}
else
{
// 如果 sib 只有左子節點是黑色
if (colorOf(leftOf(sib)) == BLACK)
{
// 將 sib 的右子節點也設爲黑色
setColor(rightOf(sib), BLACK);
// 將 sib 設爲紅色
setColor(sib, RED);
rotateLeft(sib);
sib = leftOf(parentOf(x));
}
// 將 sib 的顏色設爲與 x 的父節點顏色相同
setColor(sib, colorOf(parentOf(x)));
// 將 x 的父節點設爲黑色
setColor(parentOf(x), BLACK);
// 將 sib 的左子節點設爲黑色
setColor(leftOf(sib), BLACK);
rotateRight(parentOf(x));
x = root;
}
}
}
setColor(x, BLACK);
}
public V get(Object key)
{
// 根據指定 key 取出對應的 Entry
Entry>K,V< p = getEntry(key);
// 返回該 Entry 所包含的 value
return (p==null ? null : p.value);
}
final Entry<K,V> getEntry(Object key)
{
// 如果 comparator 不爲 null，表明程序採用定製排序
if (comparator != null)
// 調用 getEntryUsingComparator 方法來取出對應的 key
return getEntryUsingComparator(key);
// 如果 key 形參的值爲 null，拋出 NullPointerException 異常
if (key == null)
throw new NullPointerException();
// 將 key 強制類型轉換爲 Comparable 實例
Comparable<? super K> k = (Comparable<? super K>) key;
// 從樹的根節點開始
Entry<K,V> p = root;
while (p != null)
{
// 拿 key 與當前節點的 key 進行比較
int cmp = k.compareTo(p.key);
// 如果 key 小於當前節點的 key，向“左子樹”搜索
if (cmp < 0)
p = p.left;
// 如果 key 大於當前節點的 key，向“右子樹”搜索
else if (cmp > 0)
p = p.right;
// 不大於、不小於，就是找到了目標 Entry
else
return p;
}
return null;
}
final Entry<K,V> getEntryUsingComparator(Object key)
{
K k = (K) key;
// 獲取該 TreeMap 的 comparator
Comparator<? super K> cpr = comparator;
if (cpr != null)
{
// 從根節點開始
Entry<K,V> p = root;
while (p != null)
{
// 拿 key 與當前節點的 key 進行比較
int cmp = cpr.compare(k, p.key);
// 如果 key 小於當前節點的 key，向“左子樹”搜索
if (cmp < 0)
p = p.left;
// 如果 key 大於當前節點的 key，向“右子樹”搜索
else if (cmp > 0)
p = p.right;
// 不大於、不小於，就是找到了目標 Entry
else
return p;
}
}
return null;
}