資料結構與演算法（十三）——紅黑樹2

三、刪除

1、介紹

　　紅黑樹的刪除類似於排序二叉樹，排序二叉樹主要分為三種情況：
　　（1）刪除沒有左孩子且沒有右孩子的結點。即：度為0。
　　（2）刪除只有左（右）孩子的結點。即：度為1。
　　（3）刪除有左孩子且有右孩子的結點。即：度為2。
　　由於紅黑樹還有顏色的區分，所以在上述三種情況的基礎上加上顏色，就是六種情況。以 {15, 7, 45, 3, 10, 25, 55, 1, 5, 75} 為例：

　　 紅黑樹有六種情況：
　　（1）刪除度為 0 的黑色結點。比如：10、25。
　　（2）刪除度為 0 的紅色結點。比如：1、5、75。
　　（3）刪除度為 1 的黑色結點。比如：55。
　　（4）刪除度為 1 的紅色結點。這種情況不存在。
　　（5）刪除度為 2 的黑色結點。比如：3、15。
　　（6）刪除度為 2 的紅色結點。比如：7、45。

2、說明

　　論證：度為 1 的紅色結點，在紅黑樹中，是不存在的！
　　所有度為 1 的情況只有以下 4 種，這裡都畫的右孩子，左孩子也是同理。

　　其中：
　　"黑-黑"和"紅-黑"，這兩種情況，都不符合紅黑樹的性質（4）從任意一個結點到其所有葉子結點，所經過的黑色結點數目必須相等。
　　"紅-紅"，不符合紅黑樹的性質（5）所有紅色結點的兩個孩子結點必須是黑色（即，紅色結點不能連續）。
　　只有"黑-紅"這種情況存在。所以，度為 1 的結點，也必然是"黑-紅"這種情況。

3、分析

　　情況（1）刪除度為 0 的黑色結點：比較複雜，後面專門討論。
　　情況（2）刪除度為 0 的紅色結點：直接刪除即可。
　　情況（3）刪除度為 1 的黑色結點：必然是"黑-紅"的結構，則，刪除當前結點（A），讓孩子結點（B）代替A，並將B改為黑色。
　　情況（4）刪除度為 1 的紅色結點：這種情況不存在。
　　情況（5）刪除度為 2 的黑色結點：
　　比如：刪除 15，用其前驅10（後繼也可以）的值代替15，再刪除10（跳到情況1）即可。

　　比如：刪除 15，用其前驅10（後繼也可以）的值代替15，再刪除10（跳到情況3）即可。

　　比如：刪除 15，用其前驅12（後繼也可以）的值代替15，再刪除12（跳到情況2）即可。

　　情況（6）刪除度為 2 的紅色結點：同情況（5），不再贅述。
　　下面，專門討論情況（1）刪除度為 0 的黑色結點。為了方便描述，先約定一下結點名稱。

 

　　由於樹的左子樹和右子樹是對稱的，所以只討論一邊的情況即可。不妨令待刪除結點 C 為左孩子，右孩子的對稱情況同理即可。

4、兄弟結點B是紅

　　B是紅：則 P 一定是黑色。BL、BR一定存在且是黑色。
　　調整方案：先對 P 左旋；然後B 和 P 互換顏色。（需注意旋轉後，這裡的 B 就不是 C 的兄弟結點。後面的描述不贅述）。此時跳轉到下面 B（此時的B是BL，BL才是C的兄弟結點） 是黑的情況。

5、兄弟結點B是黑

　　B是黑：則孩子結點BL和BR要麼不存在，要麼存在且為紅色。不可能是黑色的結點，這會違背性質（4）從任意一個結點到其所有葉子結點，所經過的黑色結點數目必須相等。
　　情況一：BR存在且為紅，B的度為1。這裡包含了度為2的情況。
　　調整方案：先對 P 左旋；然後B 和 P 互換顏色，將BR塗黑；最後直接刪除C。

　　情況二：BR不存在，BL存在且為紅，B的度為1。
　　調整方案：先對 B 右旋；然後BL 和 B 互換顏色；跳轉到上面的情況一；

　　情況三：BL、BR都不存在，B的度為0。
　　調整方案：這裡，又要分兩種情況討論，P是紅色還是黑色？
　　（1）P是紅色
　　調整方案：P 和 B 互換顏色；直接刪除C。

　　（2）P是黑色
　　調整方案：將 B 塗紅；直接刪除C；將node指向 P，遞迴進行平衡調整（不再刪除結點），直到 node 指向根 root 結點。
　　說明：最後一步有點不好理解。刪除C後，P的左右子樹黑色結點數相等了。但是經過P的路徑，即：G（P的父結點）的左（右）子樹黑色結點數會減 1。所以，需要遞迴調整 P。

6、程式碼

　　程式碼示例：完整的紅黑樹插入及刪除

public class RBTree<T extends Comparable<T>> {
    // 根結點
    private RBNode<T> root;

    public RBTree() {
    }

    public RBTree(T[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }

        for (T i : arr) {
            this.add(i);
        }
    }

    // 查詢結點 t
    public RBNode<T> findRbNode(T t) {
        return this.findRbNode(t, root);
    }

    private RBNode<T> findRbNode(T t, RBNode<T> node) {
        if (t == null || node == null) {
            return null;
        }

        if (t.compareTo(node.value) == 0) {
            return node;
        }
        if (t.compareTo(node.value) < 0) {
            return this.findRbNode(t, node.left);
        } else {
            return this.findRbNode(t, node.right);
        }
    }

    // 查詢結點 t 的前驅
    private RBNode<T> precursor(T t) {
        final RBNode<T> node = this.findRbNode(t);
        if (node == null) {
            return null;
        }
        return this.precursor(node);
    }

    private RBNode<T> precursor(RBNode<T> node) {
        // 左子樹的最大值
        if (node.left != null) {
            RBNode<T> t = node.left;
            while (t.right != null) {
                t = t.right;
            }
            return t;
        } else {
            // 這裡在刪除的情況下是不存在的.但是,就找前驅後繼來說是存在的.
            RBNode<T> temp = node.parent;
            RBNode<T> ch = node;
            while (temp != null && ch == temp.left) {
                ch = temp;
                temp = temp.parent;
            }

            return temp;
        }
    }

    // 查詢結點 t 的後繼
    private RBNode<T> successor(T t) {
        final RBNode<T> node = this.findRbNode(t);
        if (node == null) {
            return null;
        }
        return this.successor(node);
    }

    private RBNode<T> successor(RBNode<T> node) {
        // 右子樹的最小值
        if (node.right != null) {
            RBNode<T> t = node.right;
            while (t.left != null) {
                t = t.left;
            }
            return t;
        } else {
            // 這裡在刪除的情況下是不存在的.但是,就找前驅後繼來說是存在的.
            RBNode<T> temp = node.parent;
            RBNode<T> ch = node;
            while (temp != null && ch == temp.right) {
                ch = temp;
                temp = temp.parent;
            }

            return temp;
        }
    }

    public void delete(T value) {
        final RBNode<T> node = this.findRbNode(value);
        if (node == null) {
            System.out.println("待刪除的結點:" + value + " 不存在~");
            return;
        }

        this.delNode(node);
    }

    private void delNode(RBNode<T> node) {
        final int degree = node.getDegree();
        // 度為 0
        if (degree == 0) {
            // 1.紅色.直接刪
            if (node.red) {
                this.freeDegree0(node);
            } else {
                // 2.黑色
                if (node == root) {
                    this.freeDegree0(node);
                } else {
                    this.delBlackNode(node);
                }
            }
        } else if (degree == 1) {
            // 度為 1.一定是 "黑-紅"
            if (node.left != null) {
                node.value = node.left.value;
                node.left = null;
            } else {
                node.value = node.right.value;
                node.right = null;
            }
        } else {
            // 度為 2
            final RBNode<T> precursor = this.precursor(node);
            node.value = precursor.value;
            this.delNode(precursor);
        }
    }

    /* 刪除度為 1 的黑色結點 */
    private void delBlackNode(RBNode<T> node) {
        RBNode<T> temp = node;

        // 遞迴調整
        while (temp != root) {
            final RBNode<T> p = temp.parent;
            final RBNode<T> brother = temp.getBrother();

            // 兄弟 B是紅
            if (brother.red) {
                this.adjustCase1(temp); // 經過adjustCase1後,兄弟是黑色
            } else {
                // 兄弟 B是黑 .有孩子
                if (brother.left != null || brother.right != null) {
                    if (temp == p.left) {
                        if (brother.right != null) {
                            this.adjustCase2(temp);
                        } else {
                            this.adjustCase3(temp);
                        }
                    } else {
                        if (brother.left != null) {
                            this.adjustCase2(temp);
                        } else {
                            this.adjustCase3(temp);
                        }
                    }

                    break;
                } else {
                    // C-黑.兄弟 B是黑. 且沒有孩子
                    // p-紅
                    if (p.red) {
                        brother.red = true;
                        p.red = false;
                        this.freeDegree0(temp);
                        break;
                    } else {
                        // p-黑
                        brother.red = true;
                        this.freeDegree0(temp);
                        temp = p;
                    }
                }
            }
        }
    }

    // C-黑. B-紅
    private void adjustCase1(RBNode<T> node) {
        final RBNode<T> p = node.parent;
        // 左孩子.(左右對稱的)
        if (node == p.left) {
            this.leftRotate(p);
        } else {
            this.rightRotate(p);
        }

        node.parent.red = true;
        node.parent.parent.red = false;
    }

    // C-黑. B-黑. BR-紅 (遠侄子)
    private void adjustCase2(RBNode<T> node) {
        final RBNode<T> p = node.parent;
        if (node == p.left) {
            this.leftRotate(p);

            // B、P顏色互換
            node.parent.parent.red = node.parent.red;
            node.parent.red = false;
            // 塗黑遠侄子
            node.parent.parent.right.red = false;
        } else {
            this.rightRotate(p);

            // B、P顏色互換
            node.parent.parent.red = node.parent.red;
            node.parent.red = false;
            // 塗黑遠侄子
            node.parent.parent.left.red = false;
        }
        this.freeDegree0(node);
    }

    // C-黑. B-黑. BR-不存在. BL-紅 (近侄子)
    private void adjustCase3(RBNode<T> node) {
        final RBNode<T> p = node.parent;
        final RBNode<T> brother = node.getBrother();
        // C 是左孩子.BL-紅 (近侄子)
        if (brother.left != null) {
            rightRotate(brother);
        } else {
            // C 是右孩子.BR-紅 (近侄子)
            leftRotate(brother);
        }

        // BL 和 B 互換顏色
        brother.red = true;
        brother.parent.red = false;

        // 跳轉到adjustCase2
        this.adjustCase2(p);
    }

    // 直接刪除度為 0 的結點 node
    private void freeDegree0(RBNode<T> node) {
        final RBNode<T> p = node.parent;
        // 待刪除結點 node 就是root
        if (p == null) {
            root = null;
            return;
        }

        if (node == p.left) {
            p.left = null;
        } else {
            p.right = null;
        }
    }

    // 新增結點
    public void add(T value) {
        RBNode<T> newNode = new RBNode<>(value);
        if (root == null) {
            root = newNode;
            newNode.red = false;
            return;
        }

        // 1.新增
        this.add(root, newNode);

        // 2.調整
        this.fixUp(newNode);
    }

    private void fixUp(RBNode<T> newNode) {
        if (newNode == root) {
            newNode.red = false;
            return;
        }

        // newNode 的父結點為黑色
        if (!newNode.parent.red) {
            return;
        }

        /* 1.newNode 的叔叔結點存在且為紅色。*/
        final RBNode<T> uncle = newNode.getUncle();
        if (uncle != null && uncle.red) {
            newNode.parent.red = false;
            uncle.red = false;

            newNode.parent.parent.red = true;
            this.fixUp(newNode.parent.parent);
        } else {
            /* 2.newNode 的叔叔結點不存在，或者為黑色。*/
            final RBNode<T> grandFather = newNode.getGrandFather();
            // 2.1左左
            if (newNode == grandFather.left.left) {
                this.rightRotate(grandFather);
                newNode.parent.red = false;
                grandFather.red = true;
            }
            // 2.2左右
            else if (newNode == grandFather.left.right) {
                this.leftRotate(newNode.parent);
                this.rightRotate(grandFather);
                newNode.red = false;
                grandFather.red = true;
            }
            // 2.3右右
            else if (newNode == grandFather.right.right) {
                this.leftRotate(grandFather);
                newNode.parent.red = false;
                grandFather.red = true;
            }
            // 2.4右左
            else if (newNode == grandFather.right.left) {
                this.rightRotate(newNode.parent);
                this.leftRotate(grandFather);
                newNode.red = false;
                grandFather.red = true;
            }
        }
    }

    // 按 排序二叉樹 的規則插入結點
    private void add(RBNode<T> root, RBNode<T> newNode) {
        if (newNode.value.compareTo(root.value) <= 0) {
            if (root.left == null) {
                root.left = newNode;
                newNode.parent = root;
            } else {
                this.add(root.left, newNode);
            }
        } else {
            if (root.right == null) {
                root.right = newNode;
                newNode.parent = root;
            } else {
                this.add(root.right, newNode);
            }
        }
    }

    // 左旋
    private void leftRotate(RBNode<T> node) {
        if (node == null) {
            return;
        }
        final RBNode<T> p = node.parent;

        // 左旋. 應該認為 temp 不為null
        final RBNode<T> temp = node.right;
        node.right = temp.left;
        if (temp.left != null) {
            // 該結點可能不存在
            temp.left.parent = node;
        }

        temp.left = node;
        node.parent = temp;

        // 旋轉完成.修正根結點與父結點
        // 1.node為根結點
        if (node == root) {
            root = temp;
            temp.parent = null;
            return;
        }

        // 2.node不為根結點
        // node 為父結點的右孩子
        if (node == p.right) {
            p.right = temp;
        } else {
            p.left = temp;
        }
        temp.parent = p;
    }

    // 右旋
    private void rightRotate(RBNode<T> node) {
        if (node == null) {
            return;
        }

        final RBNode<T> p = node.parent;

        // 右旋. 應該認為 temp 不為null
        final RBNode<T> temp = node.left;
        node.left = temp.right;
        if (temp.right != null) {
            // 該結點可能不存在
            temp.right.parent = node;
        }

        temp.right = node;
        node.parent = temp;

        // 旋轉完成.修正根結點與父結點
        // 1.node為根結點
        if (node == root) {
            root = temp;
            temp.parent = null;
            return;
        }

        // 2.node不為根結點
        // node 為父結點的右孩子
        if (node == p.right) {
            p.right = temp;
        } else {
            p.left = temp;
        }
        temp.parent = p;
    }

    // 中序遍歷
    public void infixOrder() {
        this.infixOrder(root);
    }

    private void infixOrder(RBNode<T> root) {
        if (root != null) {
            this.infixOrder(root.left);
            System.out.print("-->" + root.value + ":" + (root.red ? "紅" : "黑"));
            this.infixOrder(root.right);
        }
    }

    /**
     * 紅黑樹 樹結點結構
     */
    protected static class RBNode<T extends Comparable<T>> {
        private T value;
        // 預設為 紅色 結點
        private boolean red = true;

        private RBNode<T> left;
        private RBNode<T> right;
        private RBNode<T> parent;

        public RBNode() {
        }

        public RBNode(T value) {
            this.value = value;
        }

        // 返回結點的度
        public int getDegree() {
            if (this.left == null && this.right == null) {
                return 0;
            }

            if ((this.left != null && this.right == null) || (this.left == null && this.right != null)) {
                return 1;
            }

            return 2;
        }

        public RBNode<T> getUncle() {
            final RBNode<T> grandFather = this.parent.parent;
            final RBNode<T> parent = this.parent;

            if (parent == grandFather.left) {
                return grandFather.right;
            }

            if (parent == grandFather.right) {
                return grandFather.left;
            }

            return null;
        }

        public RBNode<T> getGrandFather() {
            return this.parent.parent;
        }

        public RBNode<T> getBrother() {
            final RBNode<T> p = this.parent;

            return this == p.left ? p.right : p.left;
        }

        @Override
        public String toString() {
            return "RBNode{" +
                    "value=" + value +
                    ", red=" + red +
                    '}';
        }
    }
}

　　程式碼示例：測試

public class Main {
    public static void main(String[] args) {
        // Integer[] integers = {15, 7, 45, 3, 10, 25, 55, 1, 5, 75};
        Integer[] integers = {500, 100, 750, 25, 300, 550, 800, 15, 50, 520, 600, 510};
        RBTree<Integer> tree = new RBTree<>(integers);
        tree.infixOrder();

        tree.delete(300);
        System.out.println("");
        tree.infixOrder();
    }
}

　　最後，推薦一個線上構建紅黑樹的地址：https://www.cs.usfca.edu/~galles/visualization/RedBlack.html  用於讀者驗證上述程式碼的結果。上述測試案例構建的紅黑樹為：