2. 程式人生 > >高階資料結構---紅黑樹及其插入左旋右旋程式碼java實現

高階資料結構---紅黑樹及其插入左旋右旋程式碼java實現

阿新 • • 發佈：2020-04-24

前面我們說到的二叉查詢樹，可以看到根結點是初始化之後就是固定了的，後續插入的數如果都比它大，或者都比它小，那麼這個時候它就退化成了連結串列了，查詢的時間複雜度就變成了O(n),而不是理想中O(logn),就像這個樣子

 

 

 如果我們有一個平衡機制，讓這棵樹可以動起來，比如將4變成根結點，是不是查詢效率又可以提高了，這就要提到另外一種特殊的二叉樹---紅黑樹（也是一種特殊的二叉查詢樹）。JDK1.8中將HashMap底層實現的資料結構由陣列+連結串列變成了陣列+連結串列+紅黑樹。當連結串列長度超過8就轉換成紅黑樹，明顯紅黑樹的查詢效率是高於連結串列的吧。

 

紅黑樹的特點：

 

 1.每個結點不是紅色就是黑色

 2.不可能有連在一起的紅色結點（黑色的就可以），每個葉子節點都是黑色的空節點（nil），也就是說，葉子節點不儲存資料

 3.根結點都是黑色 root

 4.每個節點，從該節點到達其可達葉子節點的所有路徑，都包含相同數目的黑色節點

 5.新插入的元素都是紅色，根除外

因為紅黑樹要滿足以上特點，所以就有變色機制和旋轉平衡機制來調節樹高度。

變色：

　　當前節點紅色，父結點和叔叔結點都是紅色，將父結點和叔叔結點變成黑色，把爺爺結點設定成紅色；只有父結點是紅色，那就將父結點變黑色，爺爺結點變紅色。完成變色之後進行左旋/右旋。

注：下面的當前節點都是變化後的操作結點。

左旋：變完色之後將操作結點變成爺爺結點，以其爺爺結點去旋轉。

　　條件：當前結點（爺爺結點）父結點是紅色，叔叔是黑色，且當前結點是右子樹。

 　　操作結點指向父結點，將當前結點（變色前結點的太爺爺）右孩子的左孩子變成其右孩子，當前結點變成其右孩子的左孩子，其右孩子填補當前結點位置

右旋：

　　條件：當前結點父結點是紅色，叔叔是黑色，且當前結點是左子樹。

　　父結點變成黑色，爺爺變成紅色（這個變色就是上面的第二種變色），以太爺爺為操作結點右旋。將其左孩子的右子樹變成其左子樹，將當前結點變成其左孩子的右子樹。其做孩子填補當前位置。

左旋右旋動圖：

 

程式碼實現：真心的太抽象了，看起來簡單，程式碼實現起來，各種結點的引用指向太亂了；下面的程式碼幾乎每一行都寫了註釋，尤其是左旋和右旋

 

package com.nijunyang.algorithm.tree;

/**
 * Description: 紅黑樹
 * Created by nijunyang on 2020/4/20 20:23
 *
 * 紅黑樹的性質：
 *         1.每個結點不是紅色就是黑色
 *         2.不可能有連在一起的紅色結點（黑色的就可以），每個葉子節點都是黑色的空節點（nil），也就是說，葉子節點不儲存資料
 *         3.根結點都是黑色 root
 *         4.每個節點，從該節點到達其可達葉子節點的所有路徑，都包含相同數目的黑色節點
 *         5.新插入的元素都是紅色，根除外
 */

public class RedBlackTree {

    private Node root = Node.nil;

    public static void main(String[] args){
        RedBlackTree redBlackTree = new RedBlackTree();
        //19,5,30,1,12,35,7,13,6
        redBlackTree.insert(19);
        redBlackTree.insert(5);
        redBlackTree.insert(30);
        redBlackTree.insert(1);
        redBlackTree.insert(12);
        redBlackTree.insert(35);
        redBlackTree.insert(7);
        redBlackTree.insert(13);
        redBlackTree.insert(6);
        RedBlackTree.inOrderTraversal(redBlackTree);
        System.out.println();
    }

    public <T extends Comparable<T>> void insert(T data){
        Node<T> temp = root;
        Node<T> node = new Node<>(data);
        if (root == Node.nil) {
            root = node;
            node.parent.parent = Node.nil;
        }
        else {
            node.black = false;
            //插入
            while (true) {
                if (temp.data.compareTo(data) < 0) {
                    if (temp.rightChild == Node.nil) {
                        temp.rightChild = node;
                        node.parent = temp;
                        break;
                    } else {
                        temp = temp.rightChild;
                    }
                }
                else if (temp.data.compareTo(data) == 0) {
                    //等於保留原來資料
                    return;
                }
                else {
                    if (temp.leftChild == Node.nil) {
                        temp.leftChild = node;
                        node.parent = temp;
                        break;
                    } else {
                        temp = temp.leftChild;
                    }
                }
            }

            //變色和旋轉
            fixTree(node);

        }
    }

    private static void inOrderTraversal(RedBlackTree redBlackTree) {
        TreeUtil.inOrderTraversal(redBlackTree.root);
    }

    /**
     * 變色和旋轉
     * @param node
     * @param <T>
     */
    private <T extends Comparable<T>> void fixTree(Node<T> node) {
        /**
         * 1.變色 條件：父結點及叔叔結點都是紅色，變色過程：把父結點和叔叔結點都變成黑色，把爺爺設定成紅色，指標指向爺爺結點
         * 2.左旋：上一步將指標指向了爺爺結點.條件：當前結點（爺爺結點）父結點是紅色，叔叔是黑色，且當前結點是右子樹。進行左旋：
         * 臨時指標指向父結點，將當前結點（變色前結點的太爺爺）右孩子的左孩子變成其右孩子，當前結點變成其右孩子的左孩子，
         * 其右孩子填補當前結點位置
         *
         * 3.右旋：條件：當前結點父結點是紅色，叔叔是黑色，且當前結點是左子樹。進行右旋：
         * 父結點變成黑色，爺爺變成紅色，以太爺爺為點右旋。將其左孩子的右子樹變成其左子樹，將當前結點變成其左孩子的右子樹。其做孩子填補當前位置
         *
         */
        Node<T> currentNode = node;
        while (!currentNode.parent.black) {
            Node<T> temp;
            if (currentNode.parent == currentNode.parent.parent.leftChild) { //當前父結點是左孩子
                temp = currentNode.parent.parent.rightChild; //叔叔結點
                //變色
                if (temp != Node.nil && !temp.black) { //叔叔也是紅色，將父和叔叔都變黑色
                    currentNode.parent.black = true;
                    temp.black = true;
                    currentNode.parent.parent.black = false; //爺爺變成紅色
                    currentNode = currentNode.parent.parent; //變色完成指向爺爺
                    continue;  //進入下一次迴圈判斷爺爺的位置是否也需要變色，直到不變滿足變色了才開始左旋/右旋
                }
                if (currentNode == currentNode.parent.rightChild) { //當前結點是右子樹
                    currentNode = currentNode.parent; //以其父結點進行左旋
                    //左旋
                    leftRotate(currentNode);
                }
                //右旋
                //父結點變成黑色，爺爺變成紅色,準備右旋
                currentNode.parent.black = true;
                currentNode.parent.parent.black = false;
                //指標指向太爺爺去右旋
                currentNode = currentNode.parent.parent;
                rightRotate(currentNode);
            }
            else { //當前父結點是右孩子
                temp = currentNode.parent.parent.leftChild;
                if (temp != Node.nil && !temp.black) {
                    currentNode.parent.black = true;
                    temp.black = true;
                    currentNode.parent.parent.black = false;
                    currentNode = currentNode.parent.parent;
                    continue;
                }
                if (currentNode == currentNode.parent.leftChild) {
                    currentNode = currentNode.parent;
                    rightRotate(currentNode);
                }
                //父結點變成黑色，爺爺變成紅色,準備左旋
                currentNode.parent.black = true;
                currentNode.parent.parent.black = false;
                //指標指向太爺爺去左旋
                currentNode = currentNode.parent.parent;
                leftRotate(currentNode);
            }
        }
        root.black = true; //根結點始終黑色
    }

    /**
     * 左旋：將其右孩子的左孩子變成其右孩子，當前結點變成其右孩子的左孩子，其右孩子填補當前結點位置
     * @param node
     * @param <T>
     */
    private <T extends Comparable<T>> void leftRotate(Node<T> node) {
        Node <T> currentNode = node;
        if (currentNode.parent != Node.nil) {
            if (currentNode == currentNode.parent.leftChild) { //當前結點是其父的左孩子
                currentNode.parent.leftChild = currentNode.rightChild; // 將其右孩子變成其父的左孩子（右孩子填補當前結點位置）
            }
            else {
                currentNode.parent.rightChild = currentNode.rightChild; //將其右孩子變成其父的右孩子（右孩子填補當前結點位置）
            }

            currentNode.rightChild.parent = currentNode.parent; //修改其右孩子的父指標，移向其父（右孩子填補當前結點位置）
            currentNode.parent = currentNode.rightChild; //當前結點變成其右孩子的孩子
            if (currentNode.rightChild.leftChild != Node.nil) {
                currentNode.rightChild.leftChild.parent = currentNode; //當前結點右孩子的左孩子變成當前結點的孩子，修改父指標
            }
            currentNode.rightChild = currentNode.rightChild.leftChild; //當前結點右孩子的左孩子變成當前結點的右孩子
            currentNode.parent.leftChild = currentNode; //當前結點新的父親（以前它的右孩子）的左孩子指向當前節點
        }
        else { //根就是當前結點
            Node right = root.rightChild;
            root.rightChild = right.leftChild; //將其右孩子的左孩子變成其右孩子
            right.leftChild.parent = root; //修改對應的父指向

            root.parent = right;
            right.leftChild = root; //當前結點變成其右孩子的左孩子
            right.parent = Node.nil;
            root = right;  //右孩子填補當前位置
        }
    }

    /**
     * 右旋：父結點變成黑色，爺爺變成紅色,準備右旋。將其左孩子的右子樹變成其左子樹，將當前結點變成其左孩子的右子樹。其左孩子填補當前位置，
     * 最後當前節點變成其
     * @param node  node
     * @param <T>
     */
    private <T extends Comparable<T>> void rightRotate(Node<T> node) {
        Node <T> currentNode = node;
        if (currentNode.parent != Node.nil) {
            if (currentNode == currentNode.parent.leftChild) {       //判斷當前結點是其父的左/右結點，其左孩子填補當前位置
                currentNode.parent.leftChild = currentNode.leftChild;
            } else {
                currentNode.parent.rightChild = currentNode.leftChild;
            }

            currentNode.leftChild.parent = currentNode.parent; //其左孩子填補當前位置，左孩子父指標指向其父指標
            currentNode.parent = currentNode.leftChild; //當前結點變成其左孩子的子樹
            if (currentNode.leftChild.rightChild != Node.nil) {
                currentNode.leftChild.rightChild.parent = currentNode; //將其左孩子的右子樹變成其左子樹
            }
            currentNode.leftChild = currentNode.leftChild.rightChild; //將其左孩子的右子樹變成其左子樹
            currentNode.parent.rightChild = currentNode; //當前結點新的父親（以前它的左孩子）的右孩子指向當前節點
        } else {  //當前結點是根結點
            Node<T> left = root.leftChild;
            root.leftChild = root.leftChild.rightChild; // 將其左孩子的右子樹變成其左子樹
            left.rightChild.parent = root;
            root.parent = left;
            left.rightChild = root; //將當前結點變成其左孩子的右子樹
            left.parent = Node.nil;
            root = left; //左孩子填補當前位置
        }
    }


    private static class Node<T extends Comparable<T>> extends TreeNode<T> {
        private static final Node nil = new Node<>(null);
        T data;
        Node<T> parent = nil;
        Node<T> leftChild = nil;
        Node<T> rightChild = nil;
        boolean black = true; //預設黑色

        public Node(T data) {
            this.data = data;
        }

        @Override
        public T getData() {
            return data;
        }

        @Override
        public void setData(T data) {
            this.data = data;
        }

        @Override
        public Node<T> getLeftChild() {
            return leftChild;
        }

        public void setLeftChild(Node<T> leftChild) {
            this.leftChild = leftChild;
        }

        @Override
        public Node<T> getRightChild() {
            return rightChild;
        }

        public void setRightChild(Node<T> rightChild) {
            this.rightChild = rightChild;
        }

        @Override
        public String toString() {
            return "data=" + data;

        }
    }
}

 

中序遍歷的程式碼：

    /**
     * 二叉樹中序遍歷 左子樹 根 右子樹
     * @param node   二叉樹節點
     */
    public static<N extends TreeNode<T>, T> void inOrderTraversal(N node){
        if(node == null){
            return;
        }
        //先找左再輸出根,再去找右
        inOrderTraversal(node.getLeftChild());
        if (node.getData() != null) {
            System.out.print(node.getData());
            System.out.print(" ");
        }
        inOrderTraversal(node.getRightChild());
    }

 

TreeNode:

public class TreeNode<T> {
    protected T data;
    protected TreeNode<T> leftChild;
    protected TreeNode<T> rightChild;

    public TreeNode() {
    }
}

在 https://www.cs.usfca.edu/~galles/visualization/RedBlack.html 上面驗證了下插入程式碼的執行結果和這兒的圖解結果是一致的。19,5,30,1,12,35,7,13,6

 

 

 

因為紅黑樹通過變色和左旋/右旋機制使得個子樹的高度儘量平衡，所以他的查詢效率是O(logn)。其插入和刪除也是近似O(logn).

 

&n

相關推薦

高階資料結構---紅黑樹及其插入左旋右旋程式碼java實現

前面我們說到的二叉查詢樹，可以看到根結點是初始化之後就是固定了的，後續插入的數如果都比它大，或者都比它小，那麼這個時候它就退化成了連結串列了，查詢的時間複雜度就變成了O(n),而不是理想中O(logn),就像這個樣子      如果我們有一個平衡機制，讓這棵樹可以動起來，比如將

資料結構-----紅黑樹的插入操作

紅黑樹是一棵二叉搜尋樹；樹種每一個節點的顏色不是黑色就是紅色。本篇中只實現用節點的顏色來描述紅黑樹，性質如下： RB1：根節點和所有外部節點都是黑色； RB2：在根至外部節點路徑上，沒有連續兩個節點是紅色； RB3：在所有根至外部節點的路徑上，黑色節點的數目都相同； 實現

資料結構——紅黑樹的資料插入操作

1. 紅黑樹     1. 紅黑樹是二叉搜尋樹的優化版，應為如果二叉搜尋樹的節點大部分全集中在左子樹或右子

資料結構---紅黑樹

紅黑樹怎麼來？歷史緣由 先說二叉樹，父節點劈叉出兩個節點，就兩個，不可以多。這樣一層一層下去。 再說二叉查詢樹（基於二分查詢），同樣有上面的劈叉屬性，但是呢左中右有大小順序，左邊小於中間，中間小於右邊。 接著就是紅黑樹，幹嘛上面下來就紅黑，二叉樹如果不加以控制就成單邊樹了。因為二叉樹沒規

資料結構 -- 紅黑樹精解

普通二叉查詢樹     紅黑樹  建立節點 1 /** 2 * 紅黑樹節點 3 */ 4 class Node { 5 6 /** 節點顏色 */ 7 public Color color; 8 /** 儲存值 */

Java實現資料結構——紅黑樹

紅黑樹定義 相比二叉查詢樹，紅黑樹中的節點多個顏色屬性。通過顏色屬性，確保了從根節點到每個葉子節點的簡單路徑，沒有一條路徑超過其他路徑2倍，近似於平衡。 性質： 每個節點或是紅色，或是黑色 根節點是黑色 每個葉節點是黑色 如果一個節點是紅色，那麼它的兩個

資料結構——紅黑樹（red-black tree）

RB-tree（紅黑樹）是一種平衡二叉搜尋樹，它每個節點上增加了一個儲存位來表示節點的顏色，可以是 Red 或 Black，故得名。通過對任何一條從根到葉子的簡單路徑上各個節點的顏色進行約束，紅黑樹能夠確保沒有一條路徑會比其他路徑長出 2 倍，近似於平衡。

資料結構-紅黑樹擴張-區間樹

package com.data.struct; public class IntervalTree { private Node root; //private Node nil; public IntervalTree(int [][]data){ f

跟小刀 學習資料結構 紅黑樹的概念

當二叉樹 插入時有順序的話.那麼插入的效率會變的非常慢.就會變成非平衡樹 二叉樹:非平衡樹 ,左右倆邊不同 紅黑樹:(平衡樹)增加了某些特點的額二叉樹 紅黑樹的特徵 節點要都顏色 插入和刪除的過程中

筆試面試常考資料結構紅黑樹性質總結

紅黑樹 一、定義 紅黑樹是一種特定型別的二叉樹，是在電腦科學中用到的一種資料結構，典型的用途是實現關聯陣列。它是在1972年由RudolfBayer發明的，他稱之為"對稱二叉B樹"，它現代的名字是在LeoJ.Guibas和RobertSedgewick於1978年寫的一篇論

資料結構——紅黑樹的刪除節點操作

1. 紅黑樹的刪除操作過程分析     1. 首先看一下普通搜尋二叉樹的刪除操作，普通搜尋二叉樹刪除結點找

【資料結構】紅黑樹的插入(Insert)

前言：    紅黑樹是一棵二叉搜尋樹，它在每個節點上增加了一個儲存位來表示節點的顏色，可以是Red或Black。通過對任何一條從根到葉子簡單路徑上的顏色來約束，紅黑樹保證最長路徑不超過最短路徑的兩倍，因而近似於平衡。 紅黑樹的基本概念：   紅黑樹是滿足下面紅黑性質的二叉

數據結構 - 紅黑樹（Red Black Tree）插入詳解與實現（Java）

啟示 dpa con 技術分享 節點數 src 通知 一點 this 　　最終還是決定把紅黑樹的篇章一分為二，插入操作一篇，刪除操作一篇，因為合在一起寫篇幅實在太長了，寫起來都覺得累，何況是閱讀並理解的讀者。 　　　　　　紅黑樹刪除操作請參考 數據結構 - 紅黑樹（Red

資料結構和演算法精講版（陣列、棧、佇列、連結串列、遞迴、排序、二叉樹、紅黑樹、堆、雜湊表）Java版

查詢和排序是最基礎也是最重要的兩類演算法，熟練地掌握這兩類演算法，並能對這些演算法的效能進行分析很重要，這兩類演算法中主要包括二分查詢、快速排序、歸併排序等等。我們先來了解查詢演算法! 順序查詢: 順序查詢又稱線性查詢。它的過程為：從查詢表的最後一個元素開始逐個與給定關鍵字比較，若某個記錄的關鍵字和給定值比較

圖解集合7：紅黑樹概念、紅黑樹的插入及旋轉操作詳細解讀

集合 得到 2個 排序。 數據流 except boolean 修正 split 原文地址http://www.cnblogs.com/xrq730/p/6867924.html，轉載請註明出處，謝謝！ 初識TreeMap 之前的文章講解了兩種Map，分別是HashMa

數據結構 - 紅黑樹

必須 現在 管理 對稱 集合 不一定 處理 轉變 .com 紅黑樹(一)之 原理和算法詳細介紹 R-B Tree簡介 R-B Tree，全稱是Red-Black Tree，又稱為“紅黑樹”，它一種特殊的二叉查找樹。紅黑樹的每個節點上都有存儲位表示節點的顏色，可以

數據結構 - 紅黑樹（Red Black Tree）刪除詳解與實現（Java）

replace ati 轉載 之前 9.png one com 四種 簡單 　　本篇要講的就是紅黑樹的刪除操作 　　　　　　紅黑樹插入操作請參考 數據結構 - 紅黑樹（Red Black Tree）插入詳解與實現（Java） 　　紅黑樹的刪除是紅黑樹操作中比較麻煩且比較有意

紅黑樹的插入解析

以下講解參考演算法導論： 首先回顧一下紅黑樹的性質： 1、紅黑樹的所有結點顏色是紅色或者黑色。 2、根結點是黑色 3、葉結點都為黑色 4、紅色節點的左右孩子結點為黑色（推論：紅色節點的父結點一定為黑色） 5、從樹中的任意一個結點出發，到葉結點所有路徑上黑色結點的個數相同。

紅黑樹的插入和遍歷時間複雜度分析

       在平常的工作中，最常用的一種資料結構恐怕是std::map了。因此對其的時間複雜度分析是有必要的，編寫程式時做到心中有底。 一、理論分析        在stl中std::map和std::set都採用紅黑樹的方式實現。我們知道插入一個元素到紅黑樹的時間為log(N)，其中N為當前紅黑樹的

紅黑樹之插入java實現

紅黑樹的插入又自頂向下和自底向上兩種方式，這裡的插入實現是自頂向下的方式。 具體參考的博文地址：http://www.cnblogs.com/xuqiang/archive/2011/05/16/2047001.html 這篇博文將插入的集中case都講的很清楚了。這裡就直接貼程式碼了，程式碼有點醜。