2. 程式人生 > >玩轉資料結構(18)-- 並查集

玩轉資料結構(18)-- 並查集

阿新 • • 發佈：2018-12-31

並查集(Union Find)

一、概述

由孩子節點指向父親節點的樹結構，解決連線問題，如圖來判斷兩個點之間是否是連線的

並查集：可以快速判斷網路中節點間的連線狀態【網路：抽象概念，使用者之間形成的網路】可以高效回答連線問題的資料結構

對於一組資料，主要支援兩個動作：

1.uoion(p,q)   --並，傳入資料 p 和 q,在並查集內部將這兩個資料，以及他們所在的集合合併起來

2.isConnected(p,q)   ---查詢 ，對於給定的兩個資料 p 和 q 是否屬於同一個集合

二、並查集的基本資料表示

第一版Union-Find本質就是一個數組

 對 10 個元素 （0-9）分成 2 個集合，其中 (0-4) 這 5 個元素為 集合0 ；(5-9) 這 5 個元素為 集合1

 

或者

在 isConnected(p,q)   ---查詢 中，只需要檢視  p 和 q 所對應的 Id 值是否相等即可，將檢視  p 和 q 背後的 Id 是誰的過程抽象為函式：find(p) == find(q) ,這種方式為 Quick Find,其時間複雜度為 O(1)

但 Quick Find 中的 uoion(p,q)   --並  時間複雜度為 O(n)；合併過程需要遍歷一遍所有元素, 將兩個元素的所屬集合編號合併

程式碼實現：

UF.java

public interface UF {	//定義介面

    int getSize();	//元素數量
    boolean isConnected(int p, int q);
    void unionElements(int p, int q);
}

UnionFind1.java

// 我們的第一版Union-Find
public class UnionFind1 implements UF {

    private int[] id;    // 我們的第一版Union-Find本質就是一個數組

    public UnionFind1(int size) {

        id = new int[size];

        // 初始化, 每一個id[i]指向自己, 沒有合併的元素
        for (int i = 0; i < size; i++)
            id[i] = i;
    }

    @Override
    public int getSize(){
        return id.length;
    }

    // 查詢元素p所對應的集合編號
    // O(1)複雜度
    private int find(int p) {
        if(p < 0 || p >= id.length)
            throw new IllegalArgumentException("p is out of bound.");

        return id[p];
    }

    // 檢視元素p和元素q是否所屬一個集合
    // O(1)複雜度
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    // 合併元素p和元素q所屬的集合
    // O(n) 複雜度
    @Override
    public void unionElements(int p, int q) {

        int pID = find(p);
        int qID = find(q);

        if (pID == qID)
            return;

        // 合併過程需要遍歷一遍所有元素, 將兩個元素的所屬集合編號合併
        for (int i = 0; i < id.length; i++)
            if (id[i] == pID)
                id[i] = qID;
    }
}

第二版Union-Find, 使用一個數組構建一棵指向父節點的樹

將每一個元素，看做是一個節點；其中，節點 3 指向其父節點 2，2 為根節點，其指標指向自己即可；

節點1 和 節點3 合併，則讓 節點1 所對應的指標指向 節點3 所在樹的根節點，即 節點2；

如果讓 節點7 和 節點2 合併 ，即讓 節點7 所在的 根節點5 ，指向 節點2 即可；

如果讓 節點7 和 節點3 合併 ，即讓 節點7 所在的 根節點5 ，指向 節點3 所在樹的 根節點2 即可；

 Quick Union:並查集不是一個樹結構，而是 森林結構 ，裡面存在很多樹 ，在初始親情況下有 10 棵樹，每棵樹只有一個節點；

如果執行 union 4,3 操作

再執行 union 3,8

再執行 union 6,5

再執行 union 9,4[讓節點 9 指向 節點4 所在的根節點]

在Quick Union 中，查操作 與 並操作 的時間複雜度均為 O(h) ,h為樹的高度

程式碼實現：

UF.java

public interface UF {	//定義介面

    int getSize();	//元素數量
    boolean isConnected(int p, int q);
    void unionElements(int p, int q);
}

UnionFind2.java

// 我們的第二版Union-Find
public class UnionFind2 implements UF {

    // 我們的第二版Union-Find, 使用一個數組構建一棵指向父節點的樹
    // parent[i]表示第一個元素所指向的父節點
    private int[] parent;

    // 建構函式
    public UnionFind2(int size){

        parent = new int[size];

        // 初始化, 每一個parent[i]指向自己, 表示每一個元素自己自成一個集合
        for( int i = 0 ; i < size ; i ++ )
            parent[i] = i;
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查詢過程, 查詢元素p所對應的集合編號
    // O(h)複雜度, h為樹的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        // 不斷去查詢自己的父親節點, 直到到達根節點
        // 根節點的特點: parent[p] == p
        while(p != parent[p])
            p = parent[p];
        return p;
    }

    // 檢視元素p和元素q是否所屬一個集合
    // O(h)複雜度, h為樹的高度
    @Override
    public boolean isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合併元素p和元素q所屬的集合
    // O(h)複雜度, h為樹的高度
    @Override
    public void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        parent[pRoot] = qRoot;
    }
}

三、優化

基於size的優化

並查集的實現由於對真正合並的元素不做形狀上的判斷，這個合併的過程會不斷增加樹的高度，甚至演化為 連結串列；

解決辦法：考慮(size)當前這棵樹整體有多少個節點,例如 union 4,9,正常操作如下圖

這時的高度為 4，但完全可以讓 9 指向 4 所在的根節點 8 ，即 9 指向 8；高度變為 3

程式碼實現：UnionFind3.java

// 我們的第三版Union-Find
public class UnionFind3 implements UF{

    private int[] parent; // parent[i]表示第一個元素所指向的父節點
    private int[] sz;     // sz[i]表示以i為根的集合中元素個數【新增程式碼】

    // 建構函式
    public UnionFind3(int size){

        parent = new int[size];
        sz = new int[size];  //【新增程式碼】

        // 初始化, 每一個parent[i]指向自己, 表示每一個元素自己自成一個集合
        for(int i = 0 ; i < size ; i ++){
            parent[i] = i;
            sz[i] = 1;  //【新增程式碼】
        }
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查詢過程, 查詢元素p所對應的集合編號
    // O(h)複雜度, h為樹的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        // 不斷去查詢自己的父親節點, 直到到達根節點
        // 根節點的特點: parent[p] == p
        while( p != parent[p] )
            p = parent[p];
        return p;
    }

    // 檢視元素p和元素q是否所屬一個集合
    // O(h)複雜度, h為樹的高度
    @Override
    public boolean isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合併元素p和元素q所屬的集合
    // O(h)複雜度, h為樹的高度
    @Override
    public void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if(pRoot == qRoot)	
            return;

        // 根據兩個元素所在樹的元素個數不同判斷合併方向
        // 將元素個數少的集合合併到元素個數多的集合上
        if(sz[pRoot] < sz[qRoot]){		//【新增程式碼】
            parent[pRoot] = qRoot;
            sz[qRoot] += sz[pRoot];
        }
        else{ // sz[qRoot] <= sz[pRoot]
            parent[qRoot] = pRoot;
            sz[pRoot] += sz[qRoot];
        }
    }
}

檢測時間複雜度：Main.java

import java.util.Random;

public class Main {

    private static double testUF(UF uf, int m){

        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();


        for(int i = 0 ; i < m ; i ++){
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a, b);
        }

        for(int i = 0 ; i < m ; i ++){
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {

        // UnionFind1 慢於 UnionFind2
//        int size = 100000;
//        int m = 10000;

        // UnionFind2 慢於 UnionFind1, 但UnionFind3最快
        int size = 100000;
        int m = 100000;

        UnionFind1 uf1 = new UnionFind1(size);
        System.out.println("UnionFind1 : " + testUF(uf1, m) + " s");

        UnionFind2 uf2 = new UnionFind2(size);
        System.out.println("UnionFind2 : " + testUF(uf2, m) + " s");

        UnionFind3 uf3 = new UnionFind3(size);
        System.out.println("UnionFind3 : " + testUF(uf3, m) + " s");
    }
}

輸出：如此優化，效能得到極大提升

 基於rank的優化【樹的高度】

執行 union 4,2 ，以 size 優化方式執行，高度變高了

更合理的方式： 在每一個節點上記錄以這個節點為根的對應的樹，其最大深度為多少，在真正合並的時候，應該使用深度比較低的那棵樹向深度比較高的樹進行合併；整體更加合理；稱為 基於rank 的優化，k[i] 表示根節點為 i 的樹的高度

程式碼實現：

UnionFind4.java

// 我們的第四版Union-Find
public class UnionFind4 implements UF {

    private int[] rank;   // rank[i]表示以i為根的集合所表示的樹的層數
    private int[] parent; // parent[i]表示第i個元素所指向的父節點

    // 建構函式
    public UnionFind4(int size){

        rank = new int[size];
        parent = new int[size];

        // 初始化, 每一個parent[i]指向自己, 表示每一個元素自己自成一個集合
        for( int i = 0 ; i < size ; i ++ ){
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查詢過程, 查詢元素p所對應的集合編號
    // O(h)複雜度, h為樹的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        // 不斷去查詢自己的父親節點, 直到到達根節點
        // 根節點的特點: parent[p] == p
        while(p != parent[p])
            p = parent[p];
        return p;
    }

    // 檢視元素p和元素q是否所屬一個集合
    // O(h)複雜度, h為樹的高度
    @Override
    public boolean isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合併元素p和元素q所屬的集合
    // O(h)複雜度, h為樹的高度
    @Override
    public void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        // 根據兩個元素所在樹的rank不同判斷合併方向
        // 將rank低的集合合併到rank高的集合上
        if(rank[pRoot] < rank[qRoot])
            parent[pRoot] = qRoot;
        else if(rank[qRoot] < rank[pRoot])
            parent[qRoot] = pRoot;
        else{ // rank[pRoot] == rank[qRoot]
            parent[pRoot] = qRoot;
            rank[qRoot] += 1;   // 此時, 我維護rank的值
        }
    }
}

測試時間複雜度：Main.java

import java.util.Random;

public class Main {

    private static double testUF(UF uf, int m){

        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();


        for(int i = 0 ; i < m ; i ++){
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a, b);
        }

        for(int i = 0 ; i < m ; i ++){
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {

        int size = 10000000;
        int m = 10000000;

//        UnionFind1 uf1 = new UnionFind1(size);
//        System.out.println("UnionFind1 : " + testUF(uf1, m) + " s");
//
//        UnionFind2 uf2 = new UnionFind2(size);
//        System.out.println("UnionFind2 : " + testUF(uf2, m) + " s");

        UnionFind3 uf3 = new UnionFind3(size);
        System.out.println("UnionFind3 : " + testUF(uf3, m) + " s");

        UnionFind4 uf4 = new UnionFind4(size);
        System.out.println("UnionFind4 : " + testUF(uf4, m) + " s");
    }
}

輸出：

路徑壓縮(Path Compression)

由上述幾種優化方式，知

查詢節點：左側的高度最大，其執行速度最慢；下側的高度最小，其執行速度最快；故將 高度大的樹 壓縮成為 高度小的樹 稱為路徑壓縮；

對並查集來說，每一個節點其子樹是沒有限制的，故理想情況下，希望樹的形態如下側那樣（根節點在第一層，其餘節點均在第二層），但很難實現嗎，通常只要追求高度減小即可提高執行速率；

壓縮過程：find 4  【在查詢過程中，壓縮路徑，使高度變小】

1.

、

2.

3.

程式碼實現：

UnionFind5.java

// 我們的第五版Union-Find
public class UnionFind5 implements UF {

    // rank[i]表示以i為根的集合所表示的樹的層數
    // 在後續的程式碼中, 我們並不會維護rank的語意, 也就是rank的值在路徑壓縮的過程中, 有可能不在是樹的層數值
    // 這也是我們的rank不叫height或者depth的原因, 他只是作為比較的一個標準
    private int[] rank;
    private int[] parent; // parent[i]表示第i個元素所指向的父節點

    // 建構函式
    public UnionFind5(int size){

        rank = new int[size];
        parent = new int[size];

        // 初始化, 每一個parent[i]指向自己, 表示每一個元素自己自成一個集合
        for( int i = 0 ; i < size ; i ++ ){
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查詢過程, 查詢元素p所對應的集合編號
    // O(h)複雜度, h為樹的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        while( p != parent[p] ){
            parent[p] = parent[parent[p]];
            p = parent[p];
        }
        return p;
    }

    // 檢視元素p和元素q是否所屬一個集合
    // O(h)複雜度, h為樹的高度
    @Override
    public boolean isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合併元素p和元素q所屬的集合
    // O(h)複雜度, h為樹的高度
    @Override
    public void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        // 根據兩個元素所在樹的rank不同判斷合併方向
        // 將rank低的集合合併到rank高的集合上
        if( rank[pRoot] < rank[qRoot] )
            parent[pRoot] = qRoot;
        else if( rank[qRoot] < rank[pRoot])
            parent[qRoot] = pRoot;
        else{ // rank[pRoot] == rank[qRoot]
            parent[pRoot] = qRoot;
            rank[qRoot] += 1;   // 此時, 我維護rank的值
        }
    }
}

測試：Main.java

import java.util.Random;

public class Main {

    private static double testUF(UF uf, int m){

        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();


        for(int i = 0 ; i < m ; i ++){
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a, b);
        }

        for(int i = 0 ; i < m ; i ++){
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();

        double time = (endTime - startTime) / 1000000000.0;
        return time;
    }

    public static void main(String[] args) {

        int size = 10000000;
        int m = 10000000;

//        UnionFind1 uf1 = new UnionFind1(size);
//        System.out.println("UnionFind1 : " + testUF(uf1, m) + " s");
//
//        UnionFind2 uf2 = new UnionFind2(size);
//        System.out.println("UnionFind2 : " + testUF(uf2, m) + " s");

        UnionFind3 uf3 = new UnionFind3(size);
        System.out.println("UnionFind3 : " + testUF(uf3, m) + " s");

        UnionFind4 uf4 = new UnionFind4(size);
        System.out.println("UnionFind4 : " + testUF(uf4, m) + " s");

        UnionFind5 uf5 = new UnionFind5(size);
        System.out.println("UnionFind5 : " + testUF(uf5, m) + " s");
    }
}

輸出：、

理想狀況：通過 遞迴 實現

程式碼實現：UnionFind6.java

// 我們的第六版Union-Find
public class UnionFind6 implements UF {

    // rank[i]表示以i為根的集合所表示的樹的層數
    // 在後續的程式碼中, 我們並不會維護rank的語意, 也就是rank的值在路徑壓縮的過程中, 有可能不在是樹的層數值
    // 這也是我們的rank不叫height或者depth的原因, 他只是作為比較的一個標準
    private int[] rank;
    private int[] parent; // parent[i]表示第i個元素所指向的父節點

    // 建構函式
    public UnionFind6(int size){

        rank = new int[size];
        parent = new int[size];

        // 初始化, 每一個parent[i]指向自己, 表示每一個元素自己自成一個集合
        for( int i = 0 ; i < size ; i ++ ){
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize(){
        return parent.length;
    }

    // 查詢過程, 查詢元素p所對應的集合編號
    // O(h)複雜度, h為樹的高度
    private int find(int p){
        if(p < 0 || p >= parent.length)
            throw new IllegalArgumentException("p is out of bound.");

        // path compression 2, 遞迴演算法
        if(p != parent[p])
            parent[p] = find(parent[p]);
        return parent[p];
    }

    // 檢視元素p和元素q是否所屬一個集合
    // O(h)複雜度, h為樹的高度
    @Override
    public boolean isConnected( int p , int q ){
        return find(p) == find(q);
    }

    // 合併元素p和元素q所屬的集合
    // O(h)複雜度, h為樹的高度
    @Override
    public void unionElements(int p, int q){

        int pRoot = find(p);
        int qRoot = find(q);

        if( pRoot == qRoot )
            return;

        // 根據兩個元素所在樹的rank不同判斷合併方向
        // 將rank低的集合合併到rank高的集合上
        if( rank[pRoot] < rank[qRoot] )
            parent[pRoot] = qRoot;
        else if( rank[qRoot] < rank[pRoot])
            parent[qRoot] = pRoot;
        else{ // rank[pRoot] == rank[qRoot]
            parent[pRoot] = qRoot;
            rank[qRoot] += 1;   // 此時, 我維護rank的值
        }
    }
}

測試：Main.java

import java.util.Random;

public class Main {

    private static double testUF(UF uf, int m){

        int size = uf.getSize();
        Random random = new Random();

        long startTime = System.nanoTime();


        for(int i = 0 ; i < m ; i ++){
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.unionElements(a, b);
        }

        for(int i = 0 ; i < m ; i ++){
            int a = random.nextInt(size);
            int b = random.nextInt(size);
            uf.isConnected(a, b);
        }

        long endTime = System.nanoTime();

        double time = (endTime - startTime) / 1000000000.0;
        return time;
    }

    public static void main(String[] args) {

        int size = 10000000;
        int m = 10000000;

//        UnionFind1 uf1 = new UnionFind1(size);
//        System.out.println("UnionFind1 : " + testUF(uf1, m) + " s");
//
//        UnionFind2 uf2 = new UnionFind2(size);
//        System.out.println("UnionFind2 : " + testUF(uf2, m) + " s");

        UnionFind3 uf3 = new UnionFind3(size);
        System.out.println("UnionFind3 : " + testUF(uf3, m) + " s");

        UnionFind4 uf4 = new UnionFind4(size);
        System.out.println("UnionFind4 : " + testUF(uf4, m) + " s");

        UnionFind5 uf5 = new UnionFind5(size);
        System.out.println("UnionFind5 : " + testUF(uf5, m) + " s");

        UnionFind6 uf6 = new UnionFind6(size);
        System.out.println("UnionFind6 : " + testUF(uf6, m) + " s");
    }
}

輸出：遞迴會產生一定的開銷

補充：在方式 5 中也可以變為理想狀態下的情況【不是通過 遞迴 ，通過 迴圈遍歷 來實現】

時間複雜度：O(h) --- 嚴格意思上：O(log  *n)

相關推薦

玩轉資料結構(18)-- 並查集

並查集(Union Find) 一、概述 由孩子節點指向父親節點的樹結構，解決連線問題，如圖來判斷兩個點之間是否是連線的 並查集：可以快速判斷網路中節點間的連線狀態【網路：抽象概念，使用者之間形成的網路】可以高效回答連線問題的資料結構 對於一組資料，主要支援兩

noip提高組資料結構模板[並查集,st表,樹狀陣列,線段樹]

/*資料結構*/ //並查集 for(int i=1;i<=n;i++) fa[i]=i;*** int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);} //st表 for(int i=2;i<=n;i++) Log[i]=Lo

資料結構09—— 並查集（Union-Find）

一、關於並查集 並查集（Union-Find）是一種樹型的資料結構，常用於處理一些不相交集合（Disjoint Sets）的合併及查詢問題。並查集（Union-Find）從名字可以看出，主要它涉及兩種基本操作:合併和查詢。這說明，初始時並查集中的元素是不相交的，經過一系列的基本操作(Union)

資料結構學習 並查集講解（思路，時間複雜度）

1、  概述 並查集（Disjoint set或者Union-find set）是一種樹型的資料結構，常用於處理一些不相交集合（Disjoint Sets）的合併及查詢問題。 2、  基本操作 並查集是一種非常簡單的資料結構，它主要涉及兩個基本操作，分別為： A． 合併兩個

【資料結構】——並查集

概念：所謂並查集，就是把一個集合合併再進行查詢。 並查集基本操作： 1、將a、b兩個元素合併在一個集合 2、查詢a、b是否在一個集合 那麼，我們這是就要思考：如何將每個元素合併在一個集合呢？它們之間是否存在著某個標誌? 很顯然，標誌是肯定要存在的。 首先，

*step3_資料結構_ACM並查集 HDU1272 小希的迷宮【並查集】

瘋狂WA題。 這道題就是一個簡單的並查集。 但是我在瘋狂WA題的過程中，個人覺得這道題還有點問題，首先，這道題沒有說清楚，有沒有對同一條邊輸入兩次的情況，在第一遍wa掉後，我打算解決這個問題，顯然，無果，因為測試資料沒那種情況。 在這道題應當收穫的教訓是，對這種簡單

資料結構之並查集

1.概述 英文：DisjointSet or（Union-find set），即“不相交集合”將編號分別為1…N的N個物件劃分為不相交集合，在每個集合中，選擇其中某個元素代表所在集合。 常見兩種操作： （1）合並兩個集合      （2）查找某元素屬於哪個集合 所以也成稱

【數據結構】並查集

tro 算法導論 src html target style 導論 span tony 【並查集】 　　　　　　為實現 在 不相交集合 上的操作 （1.合並兩個集合 2.查詢某個元素屬於哪個集合）而定義的一種數據結構 　　 　　其實現有兩種方式：鏈表和有根樹 　　

玩轉資料結構——第三章：最基礎的動態資料結構：連結串列

內容概括： 3-1.什麼是連結串列 3-2.在連結串列中新增元素 3-3.使用連結串列的虛擬頭結點 3-4.連結串列的遍歷，查詢和修改 3-5.從連結串列中刪除元素 3-6.使用連結串列實現棧 3-7.帶有尾指標的連結串列：使用連結串列實現佇列

玩轉資料結構——第二章：棧和佇列

內容概覽： 棧和棧的應用：撤銷操作和系統棧 棧的基本實現 棧的另外一個應用：括號匹配 關於Leetcode的更多說明 陣列佇列 迴圈佇列 迴圈佇列的實現 陣列佇列和迴圈佇列的比較 2-1.棧（Stack） 棧也是一種線性結構

玩轉資料結構入門與進階——第一章：陣列

內容大綱： 使用Java中的陣列 二次封裝屬於我們自己的陣列 向陣列中新增元素 陣列中查詢元素和修改元素 包含，搜尋，刪除功能 使用泛型 動態陣列 簡單的時間複雜度分析 均攤複雜度和防止複雜度振盪 一、java中的陣列 把資

玩轉資料結構——第四章：連結串列和遞迴

內容概要： Leetcode中和連結串列相關的問題 測試自己的Leetcode連結串列程式碼 遞迴繼承與遞迴的巨集觀語意 連結串列的天然遞迴結構性質 遞迴執行機制：遞迴的微觀解讀 遞迴演算法的除錯 更多和連結串列相關的問題 1-Leetcode中

【玩轉資料結構 從入門到進階】 佇列

package Arr; /** * 陣列佇列 * @author 大南海 * * @param <E> */ public class ArrayQueue<E> implements Queue<E> { private Array<E

玩轉資料結構從入門到進階 0基礎學好資料結構分享

課程簡介： 從資料結構基礎到二叉樹、紅黑樹、雜湊表，bobo老師精心設計本課程，詳細生動的為你講解資料結構。讓你面對資料結構可以學的會、玩的溜。掌握資料結構，完成從“搬磚”到“蓋樓”的蛻變，就在此課。各位小夥伴不要錯過！ 本門課程更側重系統地介紹資料結構，涉及基礎資料結構如

最新玩轉資料結構從入門到進階

第1章 歡迎學習《玩轉資料結構》歡迎大家學習《玩轉資料結構》課程。在這個課程中，我們將從底層實現諸多資料結構，從簡單，到複雜，並且探索他們的應用。在這一章，我們將來看一看資料結構的具體作用，學習資料結構的誤區，學習這個課程的注意事項，和課程環境的基本搭建：） ...第2章 不要小瞧陣列陣列，看

最新玩轉資料結構從入門到進階 資料結構基礎

第1章 歡迎學習《玩轉資料結構》歡迎大家學習《玩轉資料結構》課程。在這個課程中，我們將從底層實現諸多資料結構，從簡單，到複雜，並且探索他們的應用。在這一章，我們將來看一看資料結構的具體作用，學習資料結構的誤區，學習這個課程的注意事項，和課程環境的基本搭建：） ...第2章 不要小瞧陣列陣列，看似是最

【玩轉資料結構 從入門到進階】 連結串列

public class LinkList<E> { private class Node { public E e; public Node next; public Node(E e, Node next) { this.e = e; this.n

玩轉資料結構(02)--陣列_2

1.動態陣列（解決陣列空間不夠用的情況） Java 中的靜態陣列，當插入的值數量 > 陣列的size 時就會報錯，使用動態陣列可以解決這個問題， 設定動態陣列的思路：再建立一個新的陣列newData，它要比之前的陣列空間大一些；將data 中的資料放入到 new

玩轉資料結構(04)--佇列

佇列(Queue) 一、基本概念 佇列是一種線性資料結構； 相比陣列，佇列對應的操作也是陣列的子集； 只能從一端（隊尾）新增元素，只能從另一端（隊首）取出元素； 圖解：佇列就相當於排隊 由上圖知，佇列是先進先出的資料結構（First In First Out [

玩轉資料結構(08)--二分搜尋樹

二分搜尋樹(Binary Search Tree) 一、樹結構 使用樹結構的原因： 1.樹結構是一種天然的組織結構              2.資料使用樹結構儲存後，查詢高效 二叉樹：是動態資料結構【不需要在建立資料結構的時候就決定好要儲存多少資料，要新增元