【演算法】手撕紅黑樹（上）—— 基本性質以及插入實現（附帶程式碼實現）

在閱讀其他博主關於紅黑樹增刪實現的時候，博主們大多直接使用文字圖片描述，對整個增刪整體的流程突出的不太明顯（當然dalao們寫得還是很棒得，不然我也寫不出這篇文章），所以我特意花了2天時間用CAD製作了 一張插入操作的流程圖和一張刪除操作的流程圖（刪除見下篇）並手撕程式碼（好吧，其實大部分時間在除錯程式碼，畢竟talk is easy,show me the code.）。

廢話不多說了，進入正題吧。

紅黑樹是一種常見而又有點複雜的資料結構，它的應用場景有很多，比如經典的JAVA的HashMap，當slot中元素大於8時就會樹化為紅黑樹。

和AVL樹一樣，紅黑樹也是一種二叉搜尋樹（BST）。但與AVL樹不同的是，紅黑樹通過稍微犧牲其平衡性（即弱化了查詢效率），並配合其特殊的規則（下面會說）以實現在增刪上的效率提升。即相比AVL樹，增刪一個節點最多隻用旋轉三次。【紅黑樹：沒有什麼是兩次旋轉不能解決的，如果有就三次】

 

下面介紹以下紅黑樹的五個規則：

0、樹中節點不是紅色就是黑色；

1、根節點必為黑色；

2、紅色節點的父子不能也是紅色（或者說，由根至葉子的每一條路徑上不能有連續的紅節點）；

3、每個葉子節點（NIL節點）是黑色的

4、任意節點到其下方的NIL節點的每一條路徑上經過的黑色節點相同（或者說，除去紅色節點，黑色節點就是是一個AVL樹）；

5、在維護紅黑樹性質之前，對於新插入的節點，我們把它塗紅。【這其實只是一個經驗，另外，五條規則有六個不是常識麼？】

 

接下來我們就用流程圖來梳理一下紅黑樹的插入操作：

但在此之前我們先規定下圖中一些代號節點的含義以及旋轉的操作：

C節點（Curent,當前要操作節點的指標）

P節點（Parent,當前C節點的父節點）

G節點（Grandparent,當前C節點的爺爺節點）

U節點（Uncle,當前C節點的叔叔節點，即P節點的兄弟節點）   

【注意P、G、U節點應當隨著C的更新而更新】

旋轉： 以P為支點進行右旋為例——C頂替P的位置，P變為C的有右孩子，C原來的右孩子變為P的左孩子。左旋反向即可。

另外圖中白圈節點指代黑節點（畢竟CAD背景色是黑的嘛QAQ），紅圈節點就是紅節點。

 

最後附上程式碼（由於增刪方法我是一起寫的，所以程式碼中寫了刪除方法的實現，刪除方法的具體流程請參閱下篇）：

/**
 * 手撕紅黑樹
 * By 469の瘸子 （意義不明的口胡：現在應該是420の的瘸子233）
 * **/
    public class RedBlackTree<E extends Comparable<E> & PrintToDOS> {

        public static final boolean black = true;
        public static final boolean red = false;
        public Node root;

        class Node {//節點類
            public Node parent;
            public Node left;
            public Node right;
            public E element;
            public boolean color;

            public Node (E element){//構造方法，預設新節點為紅色
                this.element = element;
                this.color =red;
            }

            //列印的紅黑樹的時候，會呼叫每個節點的列印方法
            public void print(){
                //先列印顏色
                if (this.color) {
                    System.out.print("  black:");
                }else {
                    System.out.print("  red:");
                }
                //再列印值
                element.print();
                //最後列印父節並換行
                if(parent==null){
                    System.out.println("  this is root");
                }else {
                    System.out.print("  parent is:");
                    parent.element.println();
                }
            }

        }

        //插入方法，會呼叫insert方法和fixAfterInsertion方法
        public void insert(E element){
            //case1:樹中無元素，直接將elemnt插進去塗黑
            if (root==null){
                root = new Node(element);
                root.color = black;
            }else{//case2:樹非空，先按二叉搜尋樹的方式確定元素位置，再視父元素顏色分類處理
                //先把節點插進去，如果插的元素已經存在會返回null
                Node node = insertBST(element);
                //再對樹進行維護
                fixAfterInsertion(node);
            }

        }

        //該方法只負責將新的節點插進樹裡，不負責維護紅黑樹性質
        private Node insertBST(E element){
            Node pointer = root;
            Node pointer_parent = null;

            do{
                switch (element.compareTo(pointer.element)){
                    case 0:
                        System.out.println("已有當前元素！");
                        return null;
                    case 1:
                        pointer_parent = pointer;
                        pointer = pointer.right;
                        break;
                    case -1:
                        pointer_parent = pointer;
                        pointer = pointer.left;
                        break;
                    default:
                        break;
                }
            }while (pointer!=null);

            Node child = new Node(element);
            child.parent = pointer_parent;

            //compareTo的結果只會是1或-1。不會出現0，是0的話，在上方的switch語句裡就return了
            if(pointer_parent.element.compareTo(element)>0){
                pointer_parent.left = child;
            }else {
                pointer_parent.right = child;
            }
            return child;
        }

        //該方法負責插入後的維護工作
        private void fixAfterInsertion(Node node){
            Node cur,parent,grandparent,uncle;
            cur = node;
            //檢查是否需要維護樹,cur是null的話說明插的元素已存在，就不用維護了
            if(cur !=null){
                parent = cur.parent;
                //cur.print();
                //case2.1:父節點為黑色或為空，不用維護
                if(parent==null||parent.color == black){
                    return;
                }else{//case2.2:父節點為紅色，視叔叔節點顏色分類處理

                    //region 先獲取U、G節點的引用（這裡G必然非空，因為G空必然P為根且黑，那就不會執行到這裡）
                    grandparent = parent.parent;
                    if(grandparent.left == parent){
                        uncle = grandparent.right;
                    }else {
                        uncle = grandparent.left;
                    }
                    //endregion

                    //case2.2.1:U節點為黑色（NIL節點也是黑色的）。視C、P、G節點的形態處理
                    if (uncle==null||uncle.color==black){
                        //case2.2.1.1:C、P、G形態為“/”、“\”。以G為支點右旋或左旋，P變黑、G變紅
                        if(grandparent.element.compareTo(parent.element)==parent.element.compareTo(cur.element)){
                            parent.color=black;
                            grandparent.color=red;
                            if(grandparent.element.compareTo(parent.element)>0){//“/”形態，右旋
                                rightRotate(grandparent);
                            }else {//“\”形態，左旋
                                leftRotate(grandparent);
                            }
                        }else {//case2.2.1.2:C、P、G形態為“<”、“>”。先以P為支點左旋或右旋，在以P為支點右旋或左旋
                            cur.color = black;
                            grandparent.color =red;
                            if(grandparent.element.compareTo(parent.element)>0){//“<”形態，P左旋後、G右旋
                                leftRotate(parent);
                                rightRotate(grandparent);
                            }else {//“>”形態，P右旋後、G左旋
                                rightRotate(parent);
                                leftRotate(grandparent);
                            }
                        }
                    }else {//case2.2.2:U節點為紅色。將P、G、U節點換色，然後cur指向G節點呼叫維護函式
                        grandparent.color=red;
                        parent.color=black;
                        uncle.color=black;
                        fixAfterInsertion(grandparent);
                    }

                }

            }
            root.color=black;
        }

        //左旋方法
        private void leftRotate(Node node){
            Node parent = node.parent;
            Node child = node.right;
            Node childLeft = child==null?null:child.left;
        //子節點上位
            if(parent==null){//支點為根節點，parent會是空
                child.parent = null;
                root = child;
            }else {
                if (parent.left == node){
                    parent.left = child;
                    child.parent = parent;
                }else {
                    parent.right = child;
                    child.parent = parent;
                }
            }
        //父節點下位
            child.left = node;
            node.parent = child;
        //子樹調整
            node.right = childLeft;
            if(childLeft!=null){
                childLeft.parent = node;
            }
        }
        //右旋方法
        private void rightRotate(Node node){
            Node parent = node.parent;
            Node child = node.left;
            Node childRight = child==null?null:child.right;
            //子節點上位
            if(parent==null){//支點為根節點，parent會是空
                child.parent = null;
                root = child;
            }else {//支點不是根節點
                if (parent.left == node){
                    parent.left = child;
                    child.parent = parent;
                }else {
                    parent.right = child;
                    child.parent = parent;
                }
            }

            //父節點下位
            child.right = node;
            node.parent = child;
            //子樹調整
            node.left = childRight;
            if(childRight!=null){
                childRight.parent = node;
            }
        }

        //列印紅黑樹
        public void printRBT(Node node){

            if(node!=null){
                printRBT(node.left);
                node.print();
                printRBT(node.right);
            }else {
                return;
            }
        }

        public static void main(String[] args) {

            //13,8,5,11,6,22,27,25,14,17 另外一組除錯資料
            int[] nums = {1,2,3,4,5,6,7,8,9,10};
            RedBlackTree<Element> redBlackTree = new RedBlackTree<Element> ();

            for (int i: nums){
                Element element = new Element(i);
                redBlackTree.insert(element);
            }
            //列印紅黑樹
            redBlackTree.printRBT(redBlackTree.root);
            
            //刪除操作
            int value = 3;
            redBlackTree.remove(new Element(value));
            System.out.println("刪除節點"+value+"後，列印：");
            
            //列印紅黑樹
            redBlackTree.printRBT(redBlackTree.root);
        }

/**——————————  ——   分割線：以下是刪除程式碼   —————————————**/
        //從樹中刪除一個元素的程式碼
        public void remove(E element){
            Node pointer = getNodeByElement(element);
            if(pointer==null){
                System.out.print("樹中並沒有要刪除的元素");
                return;
            }
            do {
                //case1:要刪除的節點僅有一個子樹，紅黑樹性質決定該情況下刪除的必然是黑節點，且子節點為紅色葉子節點
                if ((pointer.left==null)!=(pointer.right==null)) {
                    //要刪除的節點的子樹（僅為一個紅色葉子節點）頂上來並變色
                    removeOneBranchNode(pointer);
                    return;
                } else {//case2:刪除節點為葉子節點
                    if ((pointer.left == null)&&(pointer.right == null)) {
                        removeLeafNode(pointer);
                        return;
                    } else {//case3:要刪除的節點有兩個子樹
                        //指標指向後繼節點，後繼節點element頂替要刪除的element。再do一次以判定新指標的case(此時只會是case2、3)
                        pointer = changePointer(pointer);
                    }
                }

            }while (true);
        }

        //獲取要刪除的元素的Node，若返回為null代表樹中沒有要刪除的元素
        public Node getNodeByElement(E element){
            if(root==null){//樹為空，返回null
                return  null;
            }

            Node pointer = root;
            do{
                if(element.compareTo(pointer.element)>0){//大於，指標指向右孩子
                    pointer = pointer.right;
                }else {
                    if(element.compareTo(pointer.element)<0){//小於，指標指向左孩子
                        pointer = pointer.left;
                    }else {//等於，返回當前的節點
                        return pointer;
                    }
                }
            }while (pointer!=null);
            return null;
        }

        //指標指向後繼節點，並用後繼節點的element頂替要刪除的element,沒有後繼節點就返回null
        public Node changePointer(Node pointer){
            //指標備份方便替換時找到引用
            Node pointer_old = pointer;
            //尋找後繼節點
            pointer = pointer.right;
            while (pointer.left!=null){ pointer = pointer.left; }
            pointer_old.element=pointer.element;
            return pointer;
        }

    //刪除葉子節點，紅色的就直接刪，黑色的分情況處理
        public void removeLeafNode(Node pointer){
            Node parent = pointer.parent;
            Node pointer_old = pointer;
            //case:2.1葉子節點是根節點
            if(parent==null){
                root=null;
                return;
            }
            //case:2.2葉子節點是紅色的的話直接刪除，黑色的要分類處理
            if(pointer.color==red){
                if(pointer.parent.left==pointer){
                    pointer.parent.left=null;
                }else {
                    pointer.parent.right=null;
                }
            }else {
                //case2.3:葉子節點是黑色的,視兄弟點分類處理
                while (pointer.parent!=null&&pointer.color==black){
                    parent = pointer.parent;//在case2.3.2.2下迴圈，要更新parent
                    Node brother;
                    if(pointer.parent.left==pointer){//左葉子節點處理方式
                        brother = pointer.parent.right;
                        //case2.3.1:兄弟節點為紅色。那麼將其轉換為黑色
                        if(brother.color==red){
                            brother.color = black;
                            parent.color = red;
                            leftRotate(parent);
                            brother = parent.right;
                        }
                        //case2.3.2:兄弟節點為黑色，侄子節點都是黑色（NIL）
                        if((brother.left == null)&&(brother.right == null)){
                            //case2.3.2.1:父節點為紅色
                            if(parent.color==red){
                                parent.color = black;
                                brother.color = red;
                                break;
                            }else {//case2.3.2.2:父節點為黑色
                                brother.color = red;
                                pointer = parent;
                                //繼續迴圈
                            }
                        }else {
                            //case2.3.3:兄弟節點為黑色,左侄子為紅色
                            if((brother.color==black)&&brother.left!=null&&brother.left.color==red){
                                brother.left.color = parent.color;
                                parent.color = black;
                                rightRotate(brother);
                                leftRotate(parent);
                                //case2.3.4:兄弟節點為黑色,右侄子為紅色
                            }else if((brother.color==black)&&brother.right!=null&&brother.right.color==red){
                                brother.color = parent.color;
                                parent.color = black;
                                brother.right.color = black;
                                leftRotate(parent);
                            }
                            break;
                        }
                    }else {//右葉子節點處理方式
                        brother = pointer.parent.left;
                        //case2.3.1:兄弟節點為紅色。那麼將其轉換為黑色
                        if(brother.color==red){
                            brother.color = black;
                            parent.color = red;
                            rightRotate(parent);
                            brother = parent.left;
                        }
                        //case2.3.2:兄弟節點為黑色，侄子節點都是黑色（NIL）
                        if((brother.left == null)&&(brother.right == null)){
                            //case2.3.2.1:父節點為紅色
                            if(parent.color==red){
                                parent.color = black;
                                brother.color = red;
                                break;
                            }else {//case2.3.2.2:父節點為黑色
                                brother.color = red;
                                pointer = parent;
                                //繼續迴圈
                            }

                        }else {
                            //case2.3.3:兄弟節點為黑色,右侄子為紅色
                            if((brother.color==black)&&brother.right!=null&&brother.right.color==red){
                                brother.right.color = parent.color;
                                parent.color = black;
                                leftRotate(brother);
                                rightRotate(parent);
                                //case2.3.4:兄弟節點為黑色,左侄子為紅色
                            }else if((brother.color==black)&&brother.left!=null&&brother.left.color==red){
                                brother.color = parent.color;
                                parent.color = black;
                                brother.left.color = black;
                                rightRotate(parent);
                            }
                            break;
                        }
                    }
                }
                //最後別忘了刪掉這個節點
                if(pointer_old.parent.left == pointer_old){
                    pointer_old.parent.left = null;
                }else if((pointer_old.parent.right == pointer_old)){
                    pointer_old.parent.right = null;
                }
                pointer_old.parent = null;

            }
        }

        //刪除單分支節點（此時刪除節點必為紅色，子樹僅為一個葉子節點）。子樹（就是一個葉子節點）頂上來塗黑即可。
        public void removeOneBranchNode(Node pointer){
            Node child = pointer.left!=null?pointer.left:pointer.right;
            if(pointer.parent.left==pointer){
                pointer.parent.left = child;
            }else {
                pointer.parent.right = child;
            }
            child.parent = pointer.parent;
            child.color=black;
        }



    }

 

上文中泛型E的測試用類及其列印介面：

public class Element implements Comparable<Element> ,PrintToDOS{

    public Element(int value){
        this.value = value;
    }

    public int value;

    @Override
    public void println() {
        System.out.println(value);
    }

    @Override
    public void print() { System.out.print(value); }

    //this大於element返回1，小於返回-1，相等返回0
    @Override
    public int compareTo(Element element) {
        if (this.value>element.value){
            return 1;
        }else {
            if(this.value<element.value){
                return  -1;
            }else {
                return  0;
            }
        }
    }
}

 

列印介面：

public interface PrintToDOS {
    public void print();  //列印值但不換行
    public void println();//列印值後換行
}

 

初次釋出的時候忘了加測試結果了QAQ，補上：

 

 

 

 

最後，本文如有紕漏還請dalao們指正。