查找最小生成樹：克魯斯克爾算法（Kruskal）算法

一、算法介紹

　　Kruskal算法是一種用來查找最小生成樹的算法，由Joseph Kruskal在1956年發表。用來解決同樣問題的還有Prim算法和Boruvka算法等。三種算法都是貪心算法的應用。和Boruvka算法不同的地方是，Kruskal 算法在圖中存在相同權值的邊時也有效。最小生成樹是一副連通加權無向圖中一棵權值最小的生成樹（minimum spanning tree，簡稱MST）。生成樹的權重是賦予生成樹的每條邊的權重之和。最小生成樹具有 (V – 1) 個邊，其中 V 是給定圖中的頂點數。關於最小生成樹，它可以應用在網絡設計、NP難題之類的問題，還可以用於聚類分析，還可以間接應用於其他問題。

二、Kruskal算法查找MST的步驟

1.  按權重的順序方式來對所有邊進行排序。

2.  選擇權重最小的邊。檢查它是否與形成的生成樹形成一個循環。如果未形成循環，則包括該邊。否則，將其丟棄。

3.  重復步驟2，直到生成樹中有（V-1）個邊。

 　　這個算法是貪婪算法。“貪婪的選擇”是選擇迄今為止不會造成MST成環的最小的權重邊。下面來一個例子來理解：

　　該圖包含9個頂點（V）和14個邊（E）。因此，形成的最小生成樹將具有（9 – 1）= 8 個邊。

　　步驟1：每條邊按順序來排序

    　　/**
         * 排序后：
         * 權重-src-dest
         * 1 6 7
         * 2 2 8
         * 2 5 6
         * 4 0 1
         * 4 2 5
         * 6 6 8
         * 7 2 3
         * 7 7 8
         * 8 0 7
         * 8 1 2
         * 9 3 4
         * 10 4 5
         * 11 1 7
         * 14 3 5
         */

　　步驟2+步驟3：：利用按權重排好序的邊數組，每次選取最小邊，並檢測是否成環。MST不能有環，所以這里涉及一個並查集的概念，並查集是對這個 Kruskal 算法進行優化的。

　　1）數組中一個接一個地選取所有邊。選取邊6-7：不形成循環，將其包括在內。

　　2）選取邊2-8：不形成循環，將其包括在內。

　　3）選取邊5-6：不形成循環，將其包括在內。

　　4）選取邊0-1：不形成循環，將其包括在內。

　　5）選取邊2-5：不形成循環，將其包括在內。

　　6）選取邊6-8：由於包括該邊會導致成環，因此將其丟棄。

　　7）選取邊2-3：不形成循環，將其包括在內。

　　8）選取邊7-8：由於包括該邊會導致循環，因此請將其丟棄。

　　9）選取邊0-7：不形成循環，將其包括在內。

 　  10）選取邊1-2：由於包括該邊會導致循環，因此請將其丟棄。

　   11）選取邊3-4：不形成循環，將其包括在內。

 　　由於包含的邊數等於（V – 1），因此算法結束。

三、算法代碼

並查集：

　　在計算機科學中，並查集是一種樹型的數據結構，用於處理一些不交集（Disjoint Sets）的合並及查詢問題。有一個聯合-查找算法（union-find algorithm）定義了兩個用於此數據結構的操作：

• Find：確定元素屬於哪一個子集。它可以被用來確定兩個元素是否屬於同一子集。

• Union：將兩個子集合並成同一個集合。

　　並查集樹是一種將每一個集合以樹表示的數據結構，其中每一個節點保存着到它的父節點的引用。

　　在並查集樹中，每個集合的代表即是集合的根節點。“查找”根據其父節點的引用向根行進直到到底樹根。“聯合”將兩棵樹合並到一起，這通過將一棵樹的根連接到另一棵樹的根。實現這樣操作的一種方法是：

　　查找元素 i 的集合，根據其父節點的引用向根行進直到到底樹根：

    private int find(Subset[] subsets, int i) {
        if (subsets[i].parent != i)
            subsets[i].parent = find(subsets, subsets[i].parent);   // 路徑壓縮，找到最久遠的祖先時“順便”把它的子孫直接連接到它上面
        return subsets[i].parent;
    }

　　將兩組不相交集合 x 和 y 進行並集，找到其中一個子集最父親的父親（也就是最久遠的祖先），將另外一個子集的最久遠的祖先的父親指向它：

    public void union(Subset[] subsets, int x, int y) {
        int xroot = find(subsets, x);
        int yroot = find(subsets, y);

        /* 在高秩樹的根下附加秩低樹（按秩划分合並） */
        if (subsets[xroot].rank < subsets[yroot].rank) {
            subsets[xroot].parent = yroot;
        } else if (subsets[xroot].rank > subsets[yroot].rank){
            subsets[yroot].parent = xroot;
        } else {    // 當兩棵秩同為r的樹聯合(作並集)時，它們的秩r+1
            subsets[yroot].parent = xroot;
            subsets[xroot].rank++;
        }
    }

　　同時使用路徑壓縮、按秩（rank）合並優化的程序每個操作的平均時間僅為 O(α (n))，其中α (n) 是 n=f(x)=A(x, x) 的反函數，A 是急速增加的阿克曼函數。因為 α(n) 是其反函數，故 α (n) 在 n 十分巨大時還是小於 5。因此，平均運行時間是一個極小的常數。實際上，這是漸近最優算法。

Kruskal算法

　　使用算法的思想來構造MST。

    /**
     * 使用Kruskal算法構造MST
     */
    public void kruskalMST() {
        Edge[] result = new Edge[V]; // 將存儲生成的MST
        int e = 0;                   // 用於result[]的索引變量
        int i = 0;                   // 用於排序的邊緣索引變量
        for (i = 0; i < V; ++i) {
            result[i] = new Edge();
        }

        /* 步驟一：對點到點的邊的權重進行排序 */
        Arrays.sort(edges);

        /* 創建V個子集*/
        Subset[] subsets = new Subset[V];
        for (i = 0; i < V; i++) {
            subsets[i] = new Subset();
        }

        /* 使用單個元素創建V子集 */
        for (int v = 0; v < V; v++) {
            subsets[v].parent = v;
            subsets[v].rank = 0;    // 單元素的樹的秩定義為0
        }

        /* 用於挑選下一個邊的索引 */
        i = 0;

        while (e < V-1) {
            /* 步驟2：選取最小的邊緣, 並增加下一次迭代的索引 */
            Edge next_edge = edges[i++];

            int x = find(subsets, next_edge.src);
            int y = find(subsets, next_edge.dest);

            /* 如果包括此邊不引起mst成環（樹本無環），則將其包括在結果中並為下一個邊增加結果索引存下一條邊 */
            /* 這里判斷兩個元素是否屬於一個子集 */
            if (x != y) {
                result[e++] = next_edge;
                union(subsets, x, y);
            }
            /* 否則丟棄next_edge */
        }

        /* 打印result[]的內容以顯示里面所構造的MST */
        System.out.println("Following are the edges in the constructed MST");
        for (i = 0; i < e; ++i) {
            System.out.println(result[i].src + " -- " + result[i].dest + " == " + result[i].weight);
        }
    }

　　平均時間復雜度為O (|E|·log |V|)，其中 E 和 V 分別是圖的邊集和點集。

本文源代碼：

package algorithm.mst;

import java.util.Arrays;

public class KruskalAlgorithm {
    /* 頂點數和邊數 */
    private int V, E;
    /* 所有邊的集合 */
    private Edge[] edges;

    /**
     * 創建一個V個頂點和E條邊的圖
     *
     * @param v
     * @param e
     */
    public KruskalAlgorithm(int v, int e) {
        V = v;
        E = e;
        edges = new Edge[E];
        for (int i = 0; i < e; i++) {
            edges[i] = new Edge();
        }
    }

    /**
     * 查找元素i的集合（路徑壓縮）
     * 根據其父節點的引用向根行進直到到底樹根
     *
     * @param subsets
     * @param i
     * @return
     */
    private int find(Subset[] subsets, int i) {
        if (subsets[i].parent != i)
            subsets[i].parent = find(subsets, subsets[i].parent);   // 路徑壓縮，找到最久遠的祖先時“順便”把它的子孫直接連接到它上面
        return subsets[i].parent;
    }

    /**
     * 將兩組不相交集合x和y進行並集（按秩合並）
     * 這個方法找到其中一個子集最父親的父親（也就是最久遠的祖先），將另外一個子集的最久遠的祖先的父親指向它。
     * <p>
     *     並查集樹的最基礎的表示方法，這個方法不會比鏈表法好，
     *     這是因為創建的樹可能會嚴重不平衡。
     *     所以采用“按秩合並”來優化。
     * </p>
     * <p>
     *     即總是將更小的樹連接至更大的樹上。因為影響運行時間的是樹的深度，
     *     更小的樹添加到更深的樹的根上將不會增加秩除非它們的秩相同。
     *     在這個算法中，術語“秩”替代了“深度”，因為同時應用了路徑壓縮時秩將不會與高度相同。
     * </p>
     *
     * @param subsets
     * @param x
     * @param y
     */
    public void union(Subset[] subsets, int x, int y) {
        int xroot = find(subsets, x);
        int yroot = find(subsets, y);

        /* 在高秩樹的根下附加秩低樹（按秩划分合並） */
        if (subsets[xroot].rank < subsets[yroot].rank) {
            subsets[xroot].parent = yroot;
        } else if (subsets[xroot].rank > subsets[yroot].rank){
            subsets[yroot].parent = xroot;
        } else {    // 當兩棵秩同為r的樹聯合(作並集)時，它們的秩r+1
            subsets[yroot].parent = xroot;
            subsets[xroot].rank++;
        }
    }

    /**
     * 使用Kruskal算法構造MST
     */
    public void kruskalMST() {
        Edge[] result = new Edge[V]; // 將存儲生成的MST
        int e = 0;                   // 用於result[]的索引變量
        int i = 0;                   // 用於排序的邊緣索引變量
        for (i = 0; i < V; ++i) {
            result[i] = new Edge();
        }

        /* 步驟一：對點到點的邊的權重進行排序 */
        Arrays.sort(edges);

        /* 創建V個子集*/
        Subset[] subsets = new Subset[V];
        for (i = 0; i < V; i++) {
            subsets[i] = new Subset();
        }

        /* 使用單個元素創建V子集 */
        for (int v = 0; v < V; v++) {
            subsets[v].parent = v;
            subsets[v].rank = 0;    // 單元素的樹的秩定義為0
        }

        /* 用於挑選下一個邊的索引 */
        i = 0;

        while (e < V-1) {
            /* 步驟2：選取最小的邊緣, 並增加下一次迭代的索引 */
            Edge next_edge = edges[i++];

            int x = find(subsets, next_edge.src);
            int y = find(subsets, next_edge.dest);

            /* 如果包括此邊不引起mst成環（樹本無環），則將其包括在結果中並為下一個邊增加結果索引存下一條邊 */
            /* 這里判斷兩個元素是否屬於一個子集 */
            if (x != y) {
                result[e++] = next_edge;
                union(subsets, x, y);
            }
            /* 否則丟棄next_edge */
        }

        /* 打印result[]的內容以顯示里面所構造的MST */
        System.out.println("Following are the edges in the constructed MST");
        for (i = 0; i < e; ++i) {
            System.out.println(result[i].src + " -- " + result[i].dest + " == " + result[i].weight);
        }
    }

    public static void main(String[] args) {
        /**
         * 排序后：
         * 權重-src-dest
         * 1 6 7
         * 2 2 8
         * 2 5 6
         * 4 0 1
         * 4 2 5
         * 6 6 8
         * 7 2 3
         * 7 7 8
         * 8 0 7
         * 8 1 2
         * 9 3 4
         * 10 4 5
         * 11 1 7
         * 14 3 5
         */
        int V = 9;
        int E = 14;
        KruskalAlgorithm graph = new KruskalAlgorithm(V, E);

        /* 另一個用例的圖:
              1 --- 2 --- 3
            / |     | \   | \
           0  |     8  \  |  4
            \ |  /  |   \ | /
              7 --- 6 --- 5
         */

        // 添加邊 0-1
        graph.edges[0].src = 0;
        graph.edges[0].dest = 1;
        graph.edges[0].weight = 4;

        // 添加邊 0-7
        graph.edges[1].src = 0;
        graph.edges[1].dest = 7;
        graph.edges[1].weight = 8;

        // 添加邊 1-2
        graph.edges[2].src = 1;
        graph.edges[2].dest = 2;
        graph.edges[2].weight = 8;

        // 添加邊 1-7
        graph.edges[3].src = 1;
        graph.edges[3].dest = 7;
        graph.edges[3].weight = 11;

        // 添加邊 2-3
        graph.edges[4].src = 2;
        graph.edges[4].dest = 3;
        graph.edges[4].weight = 7;

        // 添加邊 2-5
        graph.edges[5].src = 2;
        graph.edges[5].dest = 5;
        graph.edges[5].weight = 4;

        // 添加邊 2-8
        graph.edges[6].src = 2;
        graph.edges[6].dest = 8;
        graph.edges[6].weight = 2;

        // 添加邊 3-4
        graph.edges[7].src = 3;
        graph.edges[7].dest = 4;
        graph.edges[7].weight = 9;

        // 添加邊 3-5
        graph.edges[8].src = 3;
        graph.edges[8].dest = 5;
        graph.edges[8].weight = 14;

        // 添加邊 4-5
        graph.edges[9].src = 4;
        graph.edges[9].dest = 5;
        graph.edges[9].weight = 10;

        // 添加邊 5-6
        graph.edges[10].src = 5;
        graph.edges[10].dest = 6;
        graph.edges[10].weight = 2;

        // 添加邊 6-7
        graph.edges[11].src = 6;
        graph.edges[11].dest = 7;
        graph.edges[11].weight = 1;

        // 添加邊 6-8
        graph.edges[12].src = 6;
        graph.edges[12].dest = 8;
        graph.edges[12].weight = 6;

        // 添加邊 7-8
        graph.edges[13].src = 7;
        graph.edges[13].dest = 8;
        graph.edges[13].weight = 7;

        graph.kruskalMST();

        /* 用例通過算法得出的MST如下:
               1    2 -- 3
             /      | \   \
            0       8  \   4
             \          \
               7 -- 6 -- 5
         */
    }

    /**
     * 每條邊的信息，實現了{@link Comparable}接口,
     *      可以使用{@link Arrays}的方法隨其邊的權重的集合進行自然排序。
     */
    class Edge implements Comparable<Edge> {
        /* 這條邊的兩個頂點和它的權重 */
        private int src, dest, weight;

        @Override
        public int compareTo(Edge o) {
            return this.weight - o.weight;
        }
    }

    /**
     * 聯合查找子集的類
     */
    class Subset {
        /* 其祖先和秩 */
        private int parent, rank;
    }
}