算法與數據結構系列之[並查集-中]

上篇介紹了並查集的基本實現，這篇介紹幾種並查集的優化方法。

1.基於size優化：

上一篇當中樹實現並查集的方法中對要合併的兩個元素所在的樹的形狀沒有做任何的判斷，合併的過程中可能不斷增加樹的高度，使查找的性能變差，甚至在極端情況下，極有可能使樹退化成鏈表結構，使查詢的時間複雜度退化到O(n)。

那麼該如何進行優化呢？首先我們維護一個數組，存放每棵樹的元素的個數，每次合併時先將要合併的兩個元素對應的樹的元素進行比較，把樹的元素少的節點指向樹的元素多的節點上。

上圖，如果要將6和9合併，在不比較樹的元素個數的情況下，可能合併的結果如下圖所示：

如果比較樹的元素的個數，合併的結果如下圖所示，樹的高度和上圖比小1

代碼實現：

public class UnionFind3 implements UF {
    int[] parent;
    int[] sz; //sz[i] 表示以i爲根節點的元素色個數
    public UnionFind3(int size){
        parent = new int[size];
        sz = new int[size];
        for (int i = 0; i < size; i++) {
            parent[i] = i;
            sz[i] = 1;
        }
    }

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

    //查找i對應的集合編號
    //時間複雜度爲O（h）,h爲樹的高度
    private int find(int i){
        if(i < 0 || i>= parent.length)
            throw new IllegalArgumentException("非法索引");
        while (i != parent[i])
            i = parent[i];
        return i;
    }

    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(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 {
            parent[qRoot] =pRoot;
            sz[pRoot] += sz[qRoot];
        }
    }
}

大致測一下性能，和沒優化之前比較。

測試代碼：

public class Test {
    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 = 100000;
        int m = 100000;
        UnionFind1 unionFind1 = new UnionFind1(size);
        System.out.println("UnionFind1: " + testUF(unionFind1,m) + " s");
        UnionFind2 unionFind2 = new UnionFind2(size);
        System.out.println("UnionFind2: " + testUF(unionFind2,m) + " s");
        UnionFind3 unionFind3 = new UnionFind3(size);
        System.out.println("UnionFind3: " + testUF(unionFind3,m) + " s");

        /*UnionFind4 unionFind4 = new UnionFind4(size);
        System.out.println("UnionFind4: " + testUF(unionFind4,m) + " s");
        UnionFind5 unionFind5 = new UnionFind5(size);
        System.out.println("UnionFind5: " + testUF(unionFind5,m) + " s");
        UnionFind6 unionFind6 = new UnionFind6(size);
        System.out.println("UnionFind6: " + testUF(unionFind6,m) + " s");*/
    }
}

執行結果

由執行結果大致可以清楚優化後的速度比優化前要快很多，所以這種優化是很有必要的。

2.基於rank的優化

上面基於size的優化看似沒有問題，性能也較優化前提升了不少，其實還是有問題的，有的時候以樹的元素個數爲判斷標準會出現這樣的問題：深度大的節點指向了深度小的節點，從而使合併後的樹的深度更大。


那麼，基於上述的問題，可以用基於rank的優化來解決，在介紹壓縮路徑之前，可以先將rank理解爲樹的深度，通過一個數組來維護樹的深度，每次合併前都先比較要合併的兩個元素所在的樹的深度的大小，將深度小的節點指向深度大的節點，以達到使合併後的樹的深度不至於過大的目的。

上面後一種方法比前一中方法合併後樹的深度小1，當數據量很大時，這樣的優化還是能提升一些性能的。

代碼實現

public class UnionFind4 implements UF {
    int[] parent;
    int[] rank; //rank[i] 表示以i爲根節點的集合所表示的樹的層數
    public UnionFind4(int size){
        parent = new int[size];
        rank = new int[size];
        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

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

    //查找i對應的集合編號
    //時間複雜度爲O（h）,h爲樹的高度
    private int find(int i){
        if(i < 0 || i>= parent.length)
            throw new IllegalArgumentException("非法索引");
        while (i != parent[i])
            i = parent[i];
        return i;
    }

    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(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]   以pRoot和qRoot爲根節點的兩棵樹層數一樣時,合併時可以將任意一個合併到另一個即可
            parent[pRoot] = qRoot;
            rank[qRoot] += 1;  //合併完成後層數加1
        }
    }
}

性能測試

代碼同上，加上幾句即可（測試數據增大，比較更明顯）

int size = 10000000;
int m = 10000000;
System.out.println("UnionFind4: " + testUF(unionFind4,m) + " s");
UnionFind5 unionFind5 = new UnionFind5(size);

執行結果：