紅黑樹

時間 2019-11-15

原文原文鏈接

紅黑樹是一個二叉查找樹，最差性能都是lgn，因此有着良好的性能。html

介紹node

紅黑樹(Red-Black Tree，簡稱R-B Tree)，它一種特殊的二叉查找樹。
紅黑樹是特殊的二叉查找樹，意味着它知足二叉查找樹的特徵：任意一個節點所包含的鍵值，大於等於左孩子的鍵值，小於等於右孩子的鍵值。
除了具有該特性以外，紅黑樹還包括許多額外的信息。性能

紅黑樹的每一個節點上都有存儲位表示節點的顏色，顏色是紅(Red)或黑(Black)。
紅黑樹的特性:
(1) 每一個節點或者是黑色，或者是紅色。
(2) 根節點是黑色。
(3) 每一個葉子節點是黑色。 [注意：這裏葉子節點，是指爲空的葉子節點！]
(4) 若是一個節點是紅色的，則它的子節點必須是黑色的。
(5) 從一個節點到該節點的子孫節點的全部路徑上包含相同數目的黑節點。this

關於它的特性，須要注意的是：
第一，特性(3)中的葉子節點，是隻爲空(NIL或null)的節點。
第二，特性(5)，確保沒有一條路徑會比其餘路徑長出倆倍。於是，紅黑樹是相對是接近平衡的二叉樹。spa

紅黑樹的插入

地址 https://www.cnblogs.com/skywang12345/p/3624343.htmlcode

2. 左旋htm

3. 右旋blog

根據被插入節點的父節點的狀況，能夠將"當節點z被着色爲紅色節點，並插入二叉樹"劃分爲三種狀況來處理。
① 狀況說明：被插入的節點是根節點。
處理方法：直接把此節點塗爲黑色。
② 狀況說明：被插入的節點的父節點是黑色。
處理方法：什麼也不須要作。節點被插入後，仍然是紅黑樹。
③ 狀況說明：被插入的節點的父節點是紅色。
處理方法：那麼，該狀況與紅黑樹的「特性(5)」相沖突。這種狀況下，被插入節點是必定存在非空祖父節點的；進一步的講，被插入節點也必定存在叔叔節點(即便叔叔節點爲空，咱們也視之爲存在，空節點自己就是黑色節點)。理解這點以後，咱們依據"叔叔節點的狀況"，將這種狀況進一步劃分爲3種狀況(Case)。遞歸

	現象說明	處理策略
Case 1	當前節點的父節點是紅色，且當前節點的祖父節點的另外一個子節點（叔叔節點）也是紅色。	(01) 將「父節點」設爲黑色。 (02) 將「叔叔節點」設爲黑色。 (03) 將「祖父節點」設爲「紅色」。 (04) 將「祖父節點」設爲「當前節點」(紅色節點)；即，以後繼續對「當前節點」進行操做。rem
Case 2	當前節點的父節點是紅色，叔叔節點是黑色，且當前節點是其父節點的右孩子	(01) 將「父節點」做爲「新的當前節點」。 (02) 以「新的當前節點」爲支點進行左旋。
Case 3	當前節點的父節點是紅色，叔叔節點是黑色，且當前節點是其父節點的左孩子	(01) 將「父節點」設爲「黑色」。 (02) 將「祖父節點」設爲「紅色」。 (03) 以「祖父節點」爲支點進行右旋。

上面三種狀況(Case)處理問題的核心思路都是：將紅色的節點移到根節點；而後，將根節點設爲黑色。

紅黑樹的刪除

地址https://www.zhihu.com/topic/19648609/hot

刪除有兩點注意，一是，正常刪除的節點是正常二叉樹替換要刪除的節點，被刪除的節點是紅色的時候就不用不用平衡。

先來約定涉及到的結點的名稱。咱們先用待刪除結點的孩子代替待刪除結點，而且記這個孩子爲N，記它的新的父結點爲P，它的兄弟結點，也就是父結點的另一個孩子爲S，記S的左孩子爲，記S的右孩子爲。

狀況一。N是新的根。在這種狀況下，咱們就作完了。咱們從全部路徑去除了一個黑色節點，而新根是黑色的，全部屬性都保持着。

狀況二。P爲紅色，S和S的兩個孩子都是黑色的。將P置爲黑色，S置爲紅色。這樣，不通過N的路徑上的黑色結點數目並無發生變化，而通過N結點的路徑上黑色結點的數目增長了1，恰好添補了這條路徑上刪除的黑色結點。因此紅黑樹又從新達到了平衡。

狀況三。S是黑色，S的右兒子是紅色，而N是它父親的左兒子。在這種狀況下咱們在N的父親上作左旋轉，這樣S成爲N的父親和S的右兒子的父親。咱們接着交換N的父親和S的顏色，並使S的右兒子爲黑色。子樹在它的根上的還是一樣的顏色，因此屬性3 沒有被違反。可是，N如今增長了一個黑色祖先: 要麼N的父親變成黑色，要麼它是黑色而S被增長爲一個黑色祖父。因此，經過N的路徑都增長了一個黑色節點。此時，若是一個路徑不經過N，則有兩種可能性:

它經過N 的新兄弟。那麼它之前和如今都一定經過S 和N 的父親，而它們只是交換了顏色。因此路徑保持了一樣數目的黑色節點。
它經過N 的新叔父，S 的右兒子。那麼它之前經過S、S 的父親和S的右兒子，可是如今只經過S，它被假定爲它之前的父親的顏色，和 S 的右兒子，它被從紅色改變爲黑色。合成效果是這個路徑經過了一樣數目的黑色節點。

在任何狀況下，在這些路徑上的黑色節點數目都沒有改變。因此咱們恢復了屬性4。在示意圖中的白色節點能夠是紅色或黑色，可是在變換先後都必須指定相同的顏色

狀況四。S是黑色，S的左兒子是紅色，S的右兒子是黑色，而N是它父親的左兒子。在這種狀況下咱們在S上作右旋轉，這樣S的左兒子成爲S的父親和N的新兄弟。咱們接着交換S和它的新父親的顏色。全部路徑仍有一樣數目的黑色節點，可是如今N有了一個右兒子是紅色的黑色兄弟，因此咱們進入了狀況三。N和它的父親都不受這個變換的影響。如圖2.19

狀況五。S是紅色。在這種狀況下咱們在N的父親上作左旋轉，把紅色兄弟轉換成N的祖父。咱們接着對調N的父親和祖父的顏色。儘管全部的路徑仍然有相同數目的黑色節點，如今N有了一個黑色的兄弟和一個紅色的父親，因此咱們能夠接下去按2、三或四狀況來處理。N它的新兄弟SL是黑色，由於它未旋轉前是紅色S的一個兒子。

狀況六。N的父親、S和S的兒子都是黑色的。在這種狀況下，咱們簡單的重繪S爲紅色。結果是經過S的全部路徑，它們就是之前不經過N的那些路徑，都少了一個黑色節點。由於刪除N的初始的父親使經過N的全部路徑少了一個黑色節點，這使事情都平衡了起來。可是，經過P的全部路徑如今比不經過P的路徑少了一個黑色節點，因此仍然違反屬性3。要修正這個問題，咱們要從狀況一開始，在P上作從新平衡處理。

好了。今天就到這裏了。你們本身畫畫看。下節課，咱們講具體的代碼實現。

我的代碼實現

package Search;

public class BlackRedTree<K extends Comparable<K>, V> {
    private static final boolean BLACK = false;
    private static final boolean RED = true;
    private Node root;

    private class Node {// 利用Node，在添加新節點的時候自動變成紅黑樹。
        private Node left, right, parent;
        private K key;
        private V value;
        private boolean color;

        Node(K key, V value, Node parent) {
            this.key = key;
            this.value = value;
            this.color = RED;
            this.parent = parent;
        }

        private boolean getUncleColor() {
            Node leftU = parent.parent.left;
            Node rightU = parent.parent.right;
            if (null == leftU || null == rightU) {
                return BLACK;
            } else {
                if (leftU.color == rightU.color) {
                    return RED;
                } else {
                    return BLACK;
                }
            }
        }

        private void deleteBalacne(Node node) {// 顏色平衡（刪除）,首先明白被刪除的節點若是是紅色，就直接刪除，若是是黑色，那麼一定有兄弟節點，不存在做爲黑色葉子單獨存在。
            Node left = node.parent.left;
            if (node == left) {
                balanceAtLeft(node);
            } else {
                balanceAtRight(node);
            }
        }

        private void balanceAtLeft(Node node) {// 被平衡（刪除）的節點在左邊的平衡
            if (root == node) {
                return;// 被平衡（刪除）節點是根節點，什麼也別作。
            }
            boolean nColor = node.color;
            if (nColor == RED) {// 是紅色的，不作處理。
                return;
            }
            boolean pColor = node.parent.color;
            boolean sColor = BLACK;
            boolean lColor = BLACK;
            boolean rColor = BLACK;
            if (null != node.parent.right) {
                sColor = node.parent.right.color;
                if (null != node.parent.right.left) {
                    lColor = node.parent.right.left.color;
                }
                if (null != node.parent.right.right) {
                    rColor = node.parent.right.right.color;
                }
            } // 先獲取顏色
            if (rColor == RED) {// rColor節點變黑色，p節點左旋,s變P顏色，p變黑色。
                node.parent.right.color = node.parent.color;
                node.parent.color = BLACK;
                node.parent.right.right.color = BLACK;
                node.parent.leftRotate();
                return;
            }
            if (lColor == RED) {// 讓其變成rColor節點是紅色的狀況,l變黑，s變紅，s右旋，變成上個狀況。
                node.parent.right.left.color = BLACK;
                node.parent.right.color = RED;
                node.parent.right.rightRotate();
                balanceAtLeft(node);
                return;
            }
            if (sColor == RED) {// S是紅色，P左旋，P和S交換顏色，這樣又變成了兄弟節點是黑色的狀況二了。
                node.parent.right.color = BLACK;
                node.parent.color = RED;
                node.parent.leftRotate();
                balanceAtLeft(node);
                return;
            }
            if (pColor == RED && sColor == BLACK && lColor == BLACK
                    && rColor == BLACK) {// p是紅色,S和他的節點都是黑色,P變黑，s變紅。
                node.parent.color = BLACK;
                node.parent.right.color = RED;
                return;
            }
            if (pColor == BLACK && sColor == BLACK && lColor == BLACK
                    && rColor == BLACK) {// 全黑
                node.parent.right.color = RED;// 將s節點變成紅色，以P節點在作平衡。
                deleteBalacne(node.parent);
                return;
            }

        }

        private void balanceAtRight(Node node) {// 鏡像
            if (root == node) {
                return;// 被平衡（刪除）節點是根節點，什麼也別作。
            }
            boolean nColor = node.color;
            if (nColor == RED) {// 是紅色的，不作處理。
                return;
            }
            boolean pColor = node.parent.color;
            boolean sColor = BLACK;
            boolean lColor = BLACK;
            boolean rColor = BLACK;
            if (null != node.parent.left) {
                sColor = node.parent.left.color;
                if (null != node.parent.left.left) {
                    lColor = node.parent.left.left.color;
                }
                if (null != node.parent.left.right) {
                    rColor = node.parent.left.right.color;
                }
            } // 先獲取顏色
            if (lColor == RED) {// rColor節點變黑色，p節點左旋,s變P顏色，p變黑色。
                node.parent.left.color = node.parent.color;
                node.parent.color = BLACK;
                node.parent.left.left.color = BLACK;
                node.parent.rightRotate();
                return;
            }
            if (rColor == RED) {// 讓其變成rColor節點是紅色的狀況,l變黑，s變紅，s右旋，變成上個狀況。
                node.parent.left.right.color = BLACK;
                node.parent.left.color = RED;
                node.parent.left.leftRotate();
                balanceAtRight(node);
                return;
            }
            if (sColor == RED) {// S是紅色，P左旋，P和S交換顏色，這樣又變成了兄弟節點是黑色的狀況二了。
                node.parent.left.color = BLACK;
                node.parent.color = RED;
                node.parent.rightRotate();
                balanceAtRight(node);
                return;
            }
            if (pColor == RED && sColor == BLACK && lColor == BLACK
                    && rColor == BLACK) {// p是紅色,S和他的節點都是黑色,P變黑，s變紅。
                node.parent.color = BLACK;
                node.parent.left.color = RED;
                return;
            }
            if (pColor == BLACK && sColor == BLACK && lColor == BLACK
                    && rColor == BLACK) {// 全黑
                node.parent.left.color = RED;// 將s節點變成紅色，以P節點在作平衡。
                deleteBalacne(node.parent);
                return;
            }
        }

        private void delete() {
            Node reLeft = this.left;
            Node reRight = this.right;
            Node node = this;
            
            if (isNull(reLeft) && isNull(reRight)) {// ？能夠在刪除以後作判斷嗎，最好不要,左爲空或者右爲空的狀況都是紅色節點，徹底不用作處理。
                if (this.parent == null) {
                    root = null;
                } else {
                    deleteBalacne(node);
                    if (node == this.parent.left) {// 若是直接寫node = null
                        // null不能夠，我猜測，運行的時候把本身設置為空，可是別人還留有指向這個的指針，因此空間還會有，衹是指針的地址不爲空，而內容為空。
                        this.parent.left = null;
                    } else {
                        this.parent.right = null;
                    }
                }
                return;
            }
            if (null == reLeft) {// 左爲空,不用作處理，由於是紅色的，不存在連續兩個單節點，日後移就是了。
                reRight.parent = node.parent;
                reRight.color = BLACK;
                if (null == node.parent) {
                    root = reRight;
                } else {
                    if (node == node.parent.left) {
                        node.parent.left = reRight;
                    } else {
                        node.parent.right = reRight;
                    }
                }
                return;
            }
            if (null == reRight) {// 右爲空
                reLeft.parent = node.parent;
                reLeft.color = BLACK;
                if (null == node.parent) {
                    root = reLeft;
                } else {
                    deleteBalacne(node);
                    if (node == node.parent.left) {
                        node.parent.left = reLeft;
                    } else {
                        node.parent.right = reLeft;
                    }
                }
                return;
            }
            // 剩下就是有兩個孩子的了
            Node nodeMin = getMinNode(reRight);
            node.value = nodeMin.value;
            node.key = nodeMin.key;
            nodeMin.delete();
//            Node nodeMinRight = nodeMin.right;
//            deleteBalacne(nodeMin);
//            if (nodeMin.parent.left == nodeMin) {
//                if (null != nodeMinRight) {
//                    nodeMinRight.parent = nodeMin.parent;
//                    nodeMin.parent.left = nodeMinRight;
//                    nodeMin.parent = node.parent;
//                    nodeMin.left = reLeft;
//                    nodeMin.right = reRight;
//                    node.left.parent = nodeMin;
//                    node.right.parent = nodeMin;
//
//                } else {
//                    nodeMin.parent.left = null;
//                    nodeMin.parent = node.parent;
//                    nodeMin.left = reLeft;
//                    nodeMin.right = reRight;
//                    node.left.parent = nodeMin;
//                    node.right.parent = nodeMin;
//
//                }
//            } else {
//                nodeMin.parent = node.parent;
//                nodeMin.left = reLeft;
//                node.left.parent = nodeMin;
//            }
//
//            if (null != node.parent) {
//                if (node == node.parent.left) {
//                    node.parent.left = nodeMin;
//                } else {
//                    node.parent.right = nodeMin;
//                }
//            } else {
//                root = nodeMin;
//            }

        }

        private void colorBalance() {
            if (null == parent) {// 全部的判斷都是判斷這個指針是空指針的意思。
                this.color = BLACK;
                return;
            }
            if (BLACK == parent.color) {
                return;
            }
            if (RED == parent.color) {// 父親是紅色的
                boolean uncleColor = getUncleColor();
                if (uncleColor == RED) {// 叔叔也是紅色的,父親和叔叔設置爲黑色，爺爺設置成紅色，將爺爺遞歸。
                    parent.parent.left.color = BLACK;
                    parent.parent.right.color = BLACK;
                    parent.parent.color = RED;
                    parent.parent.colorBalance();
                } else {// 叔叔是黑色
                    Node grantFather = this.parent.parent;
                    if (this.parent == grantFather.left) {
                        if (this == this.parent.right) {
                            this.parent.leftRotate();
                        }
                        grantFather.color = RED;
                        grantFather.left.color = BLACK;
                        grantFather.rightRotate();
                    } else {
                        if (this == this.parent.left) {
                            this.parent.rightRotate();
                        }
                        grantFather.color = RED;
                        grantFather.right.color = BLACK;
                        grantFather.leftRotate();
                    }
                }
            }
        }

        private void leftRotate() {// 左旋
            Node aParent = this.parent;
            Node a = this;
            Node c = this.right;

            // if ((null != c && (Integer) c.key == 8)
            // || (null != aParent && (Integer) aParent.key == 8)) {
            // System.out.println("p");
            // }
            if (null != c && null != c.left) {
                c.left.parent = a;
            }

            a.right = c.left;
            c.left = a;
            a.parent = c;
            c.parent = aParent;
            if (null != aParent) {
                if (a == aParent.left) {
                    aParent.left = c;
                } else {
                    aParent.right = c;
                }
            } else {
                root = c;
            }
        }

        private void rightRotate() {// 右旋
            Node aParent = this.parent;
            Node a = this;
            Node b = this.left;

            if (null != b && null != b.right) {
                b.right.parent = a;
            }
            a.left = b.right;
            b.right = a;
            // if ((null != b && (Integer) b.key == 8)
            // || (null != aParent && (Integer) aParent.key == 8)) {
            // System.out.println("p");
            // }
            a.parent = b;
            b.parent = aParent;
            if (null != aParent) {
                if (a == aParent.left) {
                    aParent.left = b;
                } else {
                    aParent.right = b;
                }
            } else {
                root = b;
            }
        }
    }

    private Node getMinNode(Node node) {
        if (null == node.left) {
            return node;
        } else {
            return getMinNode(node.left);
        }
    }

    public void put(K k, V v) {
        if (null == root) {
            root = new Node(k, v, null);
            root.colorBalance();
        } else {
            put(root, k, v);
        }
    }

    private boolean isNull(Node node) {
        if (null == node || null == node.key) {
            return true;
        }
        return false;
    }

    private void put(Node node, K key, V value) {
        int c = key.compareTo(node.key);
        if (0 == c) {
            node.key = key;
            node.value = value;
        } else if (0 > c) {
            if (isNull(node.left)) {
                node.left = new Node(key, value, node);// 在這一步產生了左節點
                node.left.colorBalance();
            } else {
                put(node.left, key, value);
            }
        } else {
            if (isNull(node.right)) {
                node.right = new Node(key, value, node);// 在這一步產生了右節點
                node.right.colorBalance();
            } else {
                put(node.right, key, value);
            }
        }
    }

    public void remove(K key) {
        remove(key, root);
    }

    private void remove(K key, Node node) {
        if (null == node) {
            return;
        }
        int c = key.compareTo(node.key);
        if (0 > c) {
            if (null == node.left) {
                return;
            } else {
                remove(key, node.left);
            }
        } else if (0 < c) {
            if (null == node.right) {
                return;
            } else {
                remove(key, node.right);
            }
        } else {// 開始刪除
            node.delete();
        }}

    public V get(K k) {
        if (null == root) {
            return null;
        }
        return get(k, root);
    }

    public V getRoot() {

        return root.value;

    }

    private V get(K k, Node node) {
        int c = k.compareTo(node.key);
        if (c == 0) {
            return node.value;
        } else if (0 > c) {
            if (null == node.left) {
                return null;
            } else {
                return get(k, node.left);
            }
        } else {
            if (null == node.right) {
                return null;
            } else {
                return get(k, node.right);
            }
        }
    }

}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。