死磕 java集合之TreeMap源碼分析（二）- 內含紅黑樹分析全過程

死磕 java集合之TreeMap源碼分析（二）紅黑樹插入元素的時間複雜度如何？為什麼插入元素之後要做平衡？以什麼樣的形式平衡最省時間？如果插入元素的順序不一樣，會得到同樣的樹嗎？ ...

歡迎關註我的公眾號“彤哥讀源碼”，查看更多源碼系列文章, 與彤哥一起暢游源碼的海洋。

插入元素

插入元素，如果元素在樹中存在，則替換value；如果元素不存在，則插入到對應的位置，再平衡樹。

public V put(K key, V value) {
    Entry<K,V> t = root;
    if (t == null) {
        // 如果沒有根節點，直接插入到根節點
        compare(key, key); // type (and possibly null) check
        root = new Entry<>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }
    // key比較的結果
    int cmp;
    // 用來尋找待插入節點的父節點
    Entry<K,V> parent;
    // 根據是否有comparator使用不同的分支
    Comparator<? super K> cpr = comparator;
    if (cpr != null) {
        // 如果使用的是comparator方式，key值可以為null，只要在comparator.compare()中允許即可
        // 從根節點開始遍歷尋找
        do {
            parent = t;
            cmp = cpr.compare(key, t.key);
            if (cmp < 0)
                // 如果小於0從左子樹尋找
                t = t.left;
            else if (cmp > 0)
                // 如果大於0從右子樹尋找
                t = t.right;
            else
                // 如果等於0，說明插入的節點已經存在了，直接更換其value值並返回舊值
                return t.setValue(value);
        } while (t != null);
    }
    else {
        // 如果使用的是Comparable方式，key不能為null
        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)
                // 如果小於0從左子樹尋找
                t = t.left;
            else if (cmp > 0)
                // 如果大於0從右子樹尋找
                t = t.right;
            else
                // 如果等於0，說明插入的節點已經存在了，直接更換其value值並返回舊值
                return t.setValue(value);
        } while (t != null);
    }
    // 如果沒找到，那麼新建一個節點，並插入到樹中
    Entry<K,V> e = new Entry<>(key, value, parent);
    if (cmp < 0)
        // 如果小於0插入到左子節點
        parent.left = e;
    else
        // 如果大於0插入到右子節點
        parent.right = e;

    // 插入之後的平衡
    fixAfterInsertion(e);
    // 元素個數加1（不需要擴容）
    size++;
    // 修改次數加1
    modCount++;
    // 如果插入了新節點返回空
    return null;
}

插入再平衡

插入的元素預設都是紅色，因為插入紅色元素只違背了第4條特性，那麼我們只要根據這個特性來平衡就容易多了。

根據不同的情況有以下幾種處理方式：

插入的元素如果是根節點，則直接塗成黑色即可，不用平衡；
插入的元素的父節點如果為黑色，不需要平衡；
插入的元素的父節點如果為紅色，則違背了特性4，需要平衡，平衡時又分成下麵三種情況：

（如果父節點是祖父節點的左節點）

情況	策略
1）父節點為紅色，叔叔節點也為紅色	（1）將父節點設為黑色；（2）將叔叔節點設為黑色；（3）將祖父節點設為紅色；（4）將祖父節點設為新的當前節點，進入下一次迴圈判斷；
2）父節點為紅色，叔叔節點為黑色，且當前節點是其父節點的右節點	（1）將父節點作為新的當前節點；（2）以新當節點為支點進行左旋，進入情況3）；
3）父節點為紅色，叔叔節點為黑色，且當前節點是其父節點的左節點	（1）將父節點設為黑色；（2）將祖父節點設為紅色；（3）以祖父節點為支點進行右旋，進入下一次迴圈判斷；

（如果父節點是祖父節點的右節點，則正好與上面反過來）

情況	策略
1）父節點為紅色，叔叔節點也為紅色	（1）將父節點設為黑色；（2）將叔叔節點設為黑色；（3）將祖父節點設為紅色；（4）將祖父節點設為新的當前節點，進入下一次迴圈判斷；
2）父節點為紅色，叔叔節點為黑色，且當前節點是其父節點的左節點	（1）將父節點作為新的當前節點；（2）以新當節點為支點進行右旋；
3）父節點為紅色，叔叔節點為黑色，且當前節點是其父節點的右節點	（1）將父節點設為黑色；（2）將祖父節點設為紅色；（3）以祖父節點為支點進行左旋，進入下一次迴圈判斷；

讓我們來看看TreeMap中的實現：

/**
 * 插入再平衡
 *（1）每個節點或者是黑色，或者是紅色。
 *（2）根節點是黑色。
 *（3）每個葉子節點（NIL）是黑色。（註意：這裡葉子節點，是指為空(NIL或NULL)的葉子節點！）
 *（4）如果一個節點是紅色的，則它的子節點必須是黑色的。
 *（5）從一個節點到該節點的子孫節點的所有路徑上包含相同數目的黑節點。
 */
private void fixAfterInsertion(Entry<K,V> x) {
    // 插入的節點為紅節點，x為當前節點
    x.color = RED;

    // 只有當插入節點不是根節點且其父節點為紅色時才需要平衡（違背了特性4）
    while (x != null && x != root && x.parent.color == RED) {
        if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
            // a）如果父節點是祖父節點的左節點
            // y為叔叔節點
            Entry<K,V> y = rightOf(parentOf(parentOf(x)));
            if (colorOf(y) == RED) {
                // 情況1）如果叔叔節點為紅色
                // （1）將父節點設為黑色
                setColor(parentOf(x), BLACK);
                // （2）將叔叔節點設為黑色
                setColor(y, BLACK);
                // （3）將祖父節點設為紅色
                setColor(parentOf(parentOf(x)), RED);
                // （4）將祖父節點設為新的當前節點
                x = parentOf(parentOf(x));
            } else {
                // 如果叔叔節點為黑色
                // 情況2）如果當前節點為其父節點的右節點
                if (x == rightOf(parentOf(x))) {
                    // （1）將父節點設為當前節點
                    x = parentOf(x);
                    // （2）以新當前節點左旋
                    rotateLeft(x);
                }
                // 情況3）如果當前節點為其父節點的左節點（如果是情況2）則左旋之後新當前節點正好為其父節點的左節點了）
                // （1）將父節點設為黑色
                setColor(parentOf(x), BLACK);
                // （2）將祖父節點設為紅色
                setColor(parentOf(parentOf(x)), RED);
                // （3）以祖父節點為支點進行右旋
                rotateRight(parentOf(parentOf(x)));
            }
        } else {
            // b）如果父節點是祖父節點的右節點
            // y是叔叔節點
            Entry<K,V> y = leftOf(parentOf(parentOf(x)));
            if (colorOf(y) == RED) {
                // 情況1）如果叔叔節點為紅色
                // （1）將父節點設為黑色
                setColor(parentOf(x), BLACK);
                // （2）將叔叔節點設為黑色
                setColor(y, BLACK);
                // （3）將祖父節點設為紅色
                setColor(parentOf(parentOf(x)), RED);
                // （4）將祖父節點設為新的當前節點
                x = parentOf(parentOf(x));
            } else {
                // 如果叔叔節點為黑色
                // 情況2）如果當前節點為其父節點的左節點
                if (x == leftOf(parentOf(x))) {
                    // （1）將父節點設為當前節點
                    x = parentOf(x);
                    // （2）以新當前節點右旋
                    rotateRight(x);
                }
                // 情況3）如果當前節點為其父節點的右節點（如果是情況2）則右旋之後新當前節點正好為其父節點的右節點了）
                // （1）將父節點設為黑色
                setColor(parentOf(x), BLACK);
                // （2）將祖父節點設為紅色
                setColor(parentOf(parentOf(x)), RED);
                // （3）以祖父節點為支點進行左旋
                rotateLeft(parentOf(parentOf(x)));
            }
        }
    }
    // 平衡完成後將根節點設為黑色
    root.color = BLACK;
}