1 算法概述

定义。按照边的权重顺序（从小到大），将边加入最小生成树中。加入的边不会与已经加入的边构成环，知道树中含有V-1条边为主。这些黑色的边逐渐由一片森林合并为一棵树，也就是最小生成树。这种计算方法被称为Kruskal算法。

命题O。Kruskal算法能够技术任意加权连通图的最小生成树。

证明：由命题K可知，如果下一条将别加入最小生成树中的边不会和已有的黑色边构成环，那么它就构成连接树中顶点和非树中顶点集合的一种切分。且它是目前已知的唯一一条横切边切按照权重顺序选择的边，所以它比如树权重最小的横切边。因此该算法能够连续选择权重最小的横切边，和贪心算法一致。

2 算法实现

数据结构：

• 边权重排序：使用临时数组，按照权重给数组排序
• 动态连通且判断新加入的边和已有的边是否成环（是否相连），使用之前学习的union-find算法。

Kruskal算法源代码2-1如下所示：

package edu.princeton.cs.algs4;

import java.util.Arrays;

/**
 *  最小生成树 Kruskal算法
 */
public class KruskalMST {
    private static final double FLOATING_POINT_EPSILON = 1E-12;

    /**
    * 最小生成树总权重
    */
    private double weight;
    /**
    * 最小生成树
    */
    private Queue<Edge> mst = new Queue<Edge>();

    /**
     * kruskal 计算最小生成树
     * @param G 加权连通图
     */
    public KruskalMST(EdgeWeightedGraph G) {

        // 边按照权重排序
        Edge[] edges = new Edge[G.E()];
        int t = 0;
        for (Edge e: G.edges()) {
            edges[t++] = e;
        }
        Arrays.sort(edges);

        // run greedy algorithm
        UF uf = new UF(G.V());
        for (int i = 0; i < G.E() && mst.size() < G.V() - 1; i++) {
            Edge e = edges[i];
            int v = e.either();
            int w = e.other(v);

            // 检测是否相连（成环）
            if (uf.find(v) != uf.find(w)) {
                // 合并顶点v和w
                uf.union(v, w);
                mst.enqueue(e);
                weight += e.weight();
            }
        }

        // check optimality conditions
        // assert check(G);
    }

    /**
     * 最小生成树中的边
     * @return 最小生成树中的边
     */
    public Iterable<Edge> edges() {
        return mst;
    }

    /**
     * 最小生成树总权重
     * @return 最小生成树总权重
     */
    public double weight() {
        return weight;
    }
    
    /**
    * 算法校验
    */
    private boolean check(EdgeWeightedGraph G) {

        // check total weight
        double total = 0.0;
        for (Edge e : edges()) {
            total += e.weight();
        }
        if (Math.abs(total - weight()) > FLOATING_POINT_EPSILON) {
            System.err.printf("Weight of edges does not equal weight(): %f vs. %f\n", total, weight());
            return false;
        }

        // check that it is acyclic
        UF uf = new UF(G.V());
        for (Edge e : edges()) {
            int v = e.either(), w = e.other(v);
            if (uf.find(v) == uf.find(w)) {
                System.err.println("Not a forest");
                return false;
            }
            uf.union(v, w);
        }

        // check that it is a spanning forest
        for (Edge e : G.edges()) {
            int v = e.either(), w = e.other(v);
            if (uf.find(v) != uf.find(w)) {
                System.err.println("Not a spanning forest");
                return false;
            }
        }

        // check that it is a minimal spanning forest (cut optimality conditions)
        for (Edge e : edges()) {

            // all edges in MST except e
            uf = new UF(G.V());
            for (Edge f : mst) {
                int x = f.either(), y = f.other(x);
                if (f != e) uf.union(x, y);
            }
            
            // check that e is min weight edge in crossing cut
            for (Edge f : G.edges()) {
                int x = f.either(), y = f.other(x);
                if (uf.find(x) != uf.find(y)) {
                    if (f.weight() < e.weight()) {
                        System.err.println("Edge " + f + " violates cut optimality conditions");
                        return false;
                    }
                }
            }

        }

        return true;
    }

}

• 边按照权重排序，书中使用了优先队列；
• 关于unino-find算法解决动态连通性问题，可以参考之前相关文章。它可以解决动态构建连通中，判断两个顶点是否相连，即是否边的两个顶点已经在最小生成树中，防止成环。

测试代码2-2如下所示：

public static void testKruskal() {
    String path = System.getProperty("user.dir") + File.separator + "asserts/tinyEWG.txt";
    In in = new In(path);
    EdgeWeightedGraph G = new EdgeWeightedGraph(in);
    KruskalMST mst = new KruskalMST(G);
    for (Edge e : mst.edges()) {
        StdOut.println(e);
    }
    StdOut.printf("%.5f\n", mst.weight());
}

测试结果：

0-7 0.16000
2-3 0.17000
1-7 0.19000
0-2 0.26000
5-7 0.28000
4-5 0.35000
6-2 0.40000
1.81000

Kruskal算法轨迹图2-1如下所示：

3 最小生成树小结

各种最小生成树算法性能特点，如下表3-1所示：

算法	V个顶点E条边，最坏情况下增长数量级
	空间	时间
延时Prim	E	$E\log E$
即时Prim	V	$E\log V$
Kruskal	E	$E\log E$
Fredman-Tarjan	V	E+$V\log V$
Chazelle	V	接近E
理想	V	E？

一方面目前还没有理论证明，不存在能在线性时间内得到任意图的最小生成树算法。另一方面在线性时间内计算稀疏图的最小生成树算法仍然没有进展。

结语

如果小伙伴什么问题或者指教，欢迎交流。

❓QQ:806797785

⭐️源代码仓库地址：https://gitee.com/gaogzhen/algorithm

参考链接:

[1][美]Robert Sedgewich,[美]Kevin Wayne著;谢路云译.算法：第4版[M].北京：人民邮电出版社，2012.10.p404-408.