最小生成树的 Krusal 算法和 Prim 算法 Java 实现

Kruscal算法实现最小生成树

主方法

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Solution4 {
    static class Edge{
        int u, v;
        int cost;
    };
    public static Edge[] edges = new Edge[10010];   // 存储所有的边的数据
    public static int[] root = new int[110];      // 存储每个结点所在集合
    public static int e, v;     // 分别表示边数和顶点数

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while((e = in.nextInt()) != 0){
            // 初始化每个顶点所在的集合为自己单独所处的集合
            for(int i = 0; i < 110; i++){
                root[i] = i;
            }
            // 读入所有边的数据
            v = in.nextInt();
            int a, b;
            for(int i = 0; i < e; i++){
                edges[i] = new Edge();
                edges[i].u = in.nextInt();
                edges[i].v = in.nextInt();
                edges[i].cost = in.nextInt();
            }

            // 进行 Kruscal 算法构建最小生成树
            int price = Krusal();
            if(price == -1)
                System.out.println("?");
            else
                System.out.println(price);
        }

    }
}

Krusal()函数

// Kruscal 算法生成最小生成树
public static int Krusal(){
    // 对所有边进行排序
    Arrays.sort(edges, 0, e, new Comparator<Edge>(){
        public int compare(Edge e1, Edge e2){
            return e1.cost - e2.cost;
        }
    });
    int cost = 0;   // 总花费
    int edgeCount = 0;  // 当前已归纳的边数
    // 遍历所有的边，统计当前生成树中边的数量
    for(int i = 0; i < e; i++){
        // 判断 边的链各个顶点是否属于同一个集合
        int uRoot = findRoot(edges[i].u);
        int vRoot = findRoot(edges[i].v);
        // 如果不输于则合并
        if(uRoot != vRoot){
            root[vRoot] = uRoot;
            cost += edges[i].cost;
            edgeCount++;
            if(edgeCount == v - 1)
                return cost;
        }
        // 如果边的数量等于顶点数减一，那么可以退出循环
    }
    return -1;

}

这里主要注意的并查集的findRoot()方法，非常巧妙，内部使用了一个递归来压缩路径

　　private static int findRoot(int u) {
        if(root[u] == u)
            return u;
        int uRoot = findRoot(root[root[u]]);    // 路径压缩
        root[u] = uRoot;
        return uRoot;
    }

prim()算法实现最小生生成树

import java.util.Arrays;
import java.util.Scanner;

public class PrimTest {
    // 构建最小生成树
    public static int[][] G = new int[110][110];    // 村庄的图
    public static boolean[] vis = new boolean[110]; // 判断某个村庄是否已经被访问过
    public static int[] dis = new int[110];     // 存放每个村庄到当前生成树集合的距离
    public static int e;
    public static final int INF = 1 << 30;
    public static int v;

    public static void main(String[] args) {
        // 读入数据
        Scanner in = new Scanner(System.in);

        e = in.nextInt();
        v = in.nextInt();
        for (int i = 0; i < v; i++) {
            Arrays.fill(G[i], INF);
        }
        Arrays.fill(vis, false);
        int a, b;
        // 对这个数据进行prim最小生成树算法
        for (int i = 0; i < e; i++) {
            a = in.nextInt();
            b = in.nextInt();
            G[a - 1][b - 1] = in.nextInt();
            G[b - 1][a - 1] = G[a - 1][b - 1];
        }

        // 如果仍有点的距离为 -1,说明不可达，输出？
        int price = prim(0);
        if (price == -1)
            System.out.println("?");
        else
            System.out.println(price);
    }
}

prim()函数

private static int prim(int u) {
    int price = 0;
    // 初始化距离数组
    Arrays.fill(dis, INF);
    dis[u] = 0;
    // 对每个村庄进行循环判断，每次选出其中一个点
    for (int i = 0; i < v; i++) {
        int min = INF, vil = -1;
        for (int j = 0; j < v; j++) {
            if (vis[j] == false && dis[j] < min) {
                min = dis[j];
                vil = j;
            }
        }
        if (min == INF) {
            return -1;      // 说明不可达
        }
        // 标记为已访问
        vis[vil] = true;
        price += dis[vil];
        // 更新剩下的dis[]值,更新这个村庄周边到当前生成树的最短距离
        for (int j = 0; j < v; j++) {
            if (vis[j] == false && G[vil][j] != INF && dis[j] > G[vil][j]) {
                dis[j] = G[vil][j];
            }
        }
    }
    return price;
}