Java最小生成树：Prim(普里姆)算法、Kruskal(克鲁斯卡尔)算法、案例、思路分析、代码实现

Prim(普里姆)算法

案例：修路问题(最小生成树)

有一乡有7个村庄（A,B,C,D,E,F,G）现在需要修路把7个村庄连通，各个村庄的距离用边线表示(权)，比如A-B距离5公里。问：如何修路保证各个村庄都能连通，且总的修建公路总里程最短？

修路问题的本质就是最小生成树问题，最小生成树(Minimum Cost Spanning Tree)，简称MST

• 给定一个带权的无向连通图，如何选取一颗生成树，使树上所有边上权的总和为最小，这就叫做最小生成树
• N个顶点，一定有N-1个边
• 包含所有顶点
• N-1条边都在图中
• 最小生成树的算法主要是普里姆算法和克鲁斯卡尔算法

. 思路分析

• 选择一个A点开始，A相邻没有访问过的点有：A-C[7] A-G[2] A-B[5]，权值最小的路径是A-G，所以将G标记为已访问，且将G加入到已访问的队列中，即{A,G}
• 以A点和G点为中心，相邻没有访问过的点有：A-C[7] A-B[5] G-E[4] G-F[6] G-B[3]，权值最小的路径是G-B，所以将B标记已访问，且将B加入到已访问的队列中，即{A,G,B}
• 以A点、G点、B点为中心，找到相邻没有访问过的点，判断出最小路径，加入该点到队列中，依次类推
• 最终会得到一个权值最小的最小生成树，就是最终结果

. 代码分析

public class Prim {
    public static void main(String[] args) {
        // 创建一个图对象
        Graph graph = new Graph(7);
        // 顶点信息
        char[] data = new char[]{'A','B','C','D','E','F','G'};
        // 权重关系矩阵，10000表示路不通
        int[][] weight = new int[][]{
                {10000, 5, 7, 10000, 10000, 10000, 2},
                {5, 10000, 10000, 9, 10000, 10000, 3},
                {7, 10000, 10000, 10000, 8, 10000, 10000},
                {10000, 10000, 10000, 4, 5, 10000, 6},
                {10000, 10000, 8, 10000, 10000, 5, 4},
                {10000, 10000, 10000, 4, 5, 10000, 6},
                {2, 3, 10000, 10000, 4, 6, 10000}
        };

        // 创建一个最小生成树类
        MinTree minTree = new MinTree();
        // 创建具体的图
        minTree.createGraph(graph,data,weight);
        //minTree.showMinTree(graph);

        // 获取最短路径(最小生成树)，起始索引为0，即从A点开始
        minTree.getMinRoad(graph,0);

    }

}

class MinTree{
    // 构建一个具体的图
    public void createGraph(Graph graph, char[] data, int[][] weight){
        for (int i = 0; i < graph.vertexesData.length; i++) {
            graph.vertexesData[i] = data[i];
            for (int j = 0; j < graph.vertexesData.length; j++) {
                graph.weightEdge[i][j] = weight[i][j];
            }
        }
    }

    // 遍历权重的关系矩阵
    public void showMinTree(Graph graph){
        for (int[] weight : graph.weightEdge) {
            System.out.println(Arrays.toString(weight));
        }
    }

    // 获取最短路径
    public void getMinRoad(Graph graph, int v){
        // 用于记录是否被访问，1则表示该顶点已被访问
        int[] isVisited = new int[graph.vertexCount];
        // 将起始顶点标记已访问
        isVisited[v] = 1;
        // 用于记录最小权重
        int minWeight = 10000;
        // 以下用于记录最小权重的两个顶点的下表索引
        int index1 = -1;
        int index2 = -1;

        // 第一层for循环，确定N个顶点，只能由N-1条边
        for (int k = 1; k < graph.vertexCount; k++) {
            // 第二层和第三层for循环，用于遍历权重与顶点之间的关系
            for (int i = 0; i < graph.vertexCount; i++) {
                for (int j = 0; j < graph.vertexCount; j++) {
                    // 两个顶点之间，一定是满足一个顶点已被访问，另一个顶点没有被访问
                    // 并且如果这个两个顶点之间的权重小于记录的最小权重，最小权重变量就应该重新赋值
                    if (isVisited[i]==1 && isVisited[j]==0 && graph.weightEdge[i][j] < minWeight){
                        minWeight = graph.weightEdge[i][j];
                        index1 = i;
                        index2 = j;
                    }
                }
            }
            // 一轮遍历完了，就获得了每轮的最小权重和两个顶点，输出，之后继续下一轮遍历
            // 将另一个顶点标记为已被访问
            isVisited[index2] = 1;
            System.out.println(graph.vertexesData[index1]+"->"+graph.vertexesData[index2]+": "+graph.weightEdge[index1][index2]);
            // 最小值重新赋值，为下一轮做准备
            minWeight = 10000;
        }
    }
}

class Graph{
    int vertexCount; // 顶点总个数
    char[] vertexesData; // 每个顶点的数据
    int[][] weightEdge; // 边的权值

    public Graph(int vertexCount) {
        this.vertexCount = vertexCount;
        this.vertexesData = new char[vertexCount];
        this.weightEdge = new int[vertexCount][vertexCount];
    }
}

结果：

A->G: 2
G->B: 3
G->E: 4
E->F: 5
F->D: 4
A->C: 7

Kruskal(克鲁斯卡尔)算法

从图中选取权重最小的路径，由N个顶点，依次从小到大选取N-1条边，且这些边不能形成回路。

案例：修公路站牌问题(最小生成树)

这里有7个站牌，分别是A、B、C、D、E、F、G，站牌与站牌之间有拟定路线路线上标有该路线的公里数，如何才能修一条总公里数最小且每个站牌都得到达的路线？

即问：求最小生成树？

. 思路分析

• 从图中选出权最小的路径，即 F-E[2]
• 找下一个权值最小的路径，即 C-D[3]
• 找下一格权值最小的路径，即 D-E[4]，由于C和D的终点是D，F和E的终点是F，所以该路径可算
• 找下一个权值最小的路径，即 F-B[7]，由于当C、D、E、F连通之后，这些点从小到大排列之后，重点都是F，所以C和E不能连通，C和F也不能连通，连通之后会形成回路
• 依次类推，最终得到一个最小生成树：

. 代码实现

• 1，创建图的顶点、边的矩阵、获取边的个数
• 2，创建一个边的类，存储两个顶点和边的权
• 3，将所有边存储到数组中，然后根据边的权进行排序
• 4，创建一个记录终点的数组，以及返回顶点重点的方法
• 5，遍历边的数组，根据每一个边的顶点，获取每个顶点的终点，以及设置顶点的终点
• 6，终点相同，说明该边加入会形成回路，因此需抛弃该边
• 7，最终得到一个完全符合要求的最小生成树

/**
 * Created with IntelliJ IDEA
 * User: heroC
 * Date: 2020/6/12
 * Time: 20:26
 * Description: 克鲁斯卡尔算法，最小生成树
 * 1，创建图的顶点、边的矩阵、获取边的个数
 * 2，创建一个边的类，存储两个顶点和边的权
 * 3，将所有边存储到数组中，然后根据边的权进行排序
 * 4，创建一个记录终点的数组，以及返回顶点重点的方法
 * 5，遍历边的数组，根据每一个边的顶点，获取每个顶点的终点，以及设置顶点的终点
 * 6，终点相同，说明该边加入会形成回路，因此需抛弃该边
 * 7，最终得到一个完全符合要求的最小生成树
 * Version: V1.0
 */
public class Kruskal {
    public static void main(String[] args) {
        // 顶点信息
        char vertexes[] = {'A','B','C','D','E','F','G'};
        // 顶点关系权矩阵
        int[][] weight = {
                {0,12,INF,INF,INF,16,14},
                {12,0,10,INF,INF,7,INF},
                {INF,10,0,3,5,6,INF},
                {INF,INF,3,0,4,INF,INF},
                {INF,INF,5,4,0,2,8},
                {16,7,6,INF,2,0,9},
                {14,INF,INF,INF,8,9,0}
        };
        // 创建一个图
        Kruskal kruskal = new Kruskal(vertexes, weight);
        // 克鲁斯卡尔算法
        kruskal.kruskalAlgorithm();

    }

    int edgesCount; // 记录边的条数
    char[] vertexData; // 记录顶点信息
    int[][] weight; // 权矩阵
    static final int INF = Integer.MAX_VALUE; // 将没有边的两点之间定义为INF，表示不连通

    // 构造器，创建一个图
    public Kruskal(char[] vertexData, int[][] weight) {
        this.edgesCount = 0;
        // 通过拷贝复制的方式，为了不改变原来数据
        int len = vertexData.length;
        this.vertexData = new char[len];
        for (int i = 0; i < vertexData.length; i++) {
            this.vertexData[i] = vertexData[i];
        }

        this.weight = new int[len][len];
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len; j++) {
                this.weight[i][j] = weight[i][j];
            }
        }
    }

    /**
     * 遍历权矩阵，获取有效边数
     * @return
     */
    public int getEdgesCount(){
        for (int i = 0; i < weight.length; i++) {
            for (int j = i+1; j < weight[0].length; j++) {
                if (weight[i][j]!= INF){
                    edgesCount++;
                }
            }
        }
        return edgesCount;
    }

    /**
     * 获得关于边的数组对象
     * @return
     */
    public Edge[] getEdgeArray(){
        Edge edges[] = new Edge[edgesCount];
        int index = 0;
        for (int i = 0; i < weight.length; i++) {
            for (int j = i+1; j < weight[0].length; j++) {
                if (weight[i][j]!= INF){
                    edges[index++] = new Edge(vertexData[i],vertexData[j],weight[i][j]);
                }
            }
        }
        return edges;
    }

    /**
     * 对边对象，进行升序排序，有利于依次选取最小权的边
     * @param edges 原始边数组
     * @return 返回排序完成的边数组
     */
    public Edge[] sortEdge(Edge[] edges){
        for (int i = 0; i < edges.length - 1; i++) {
            for (int j = 0; j < edges.length - 1 - i; j++) {
                if (edges[j].weight > edges[j+1].weight){
                    Edge temp = edges[j];
                    edges[j] = edges[j+1];
                    edges[j+1] = temp;
                }
            }
        }
        return edges;
    }

    /**
     * 根据传入的顶点数据，获取顶点对应的索引
     * @param vertex 顶点
     * @return 返回其索引
     */
    public int getVertexIndex(char vertex){
        for (int i = 0; i < vertexData.length; i++) {
            if (vertexData[i] == vertex){
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取终点顶点的索引
     * @param end 该数组是动态变化的数组，根据不同的边，会赋值新的终点给end数组
     * @param i 需要获取该顶点的终点索引的顶点索引
     * @return 返回该顶点对应的终点索引
     */
    public int getEnd(int[] end, int i){
        while (end[i] != 0){
            i = end[i];
        }
        return i;
    }

    /**
     * 克鲁斯卡尔算法
     */
    public void kruskalAlgorithm(){
        // 获取边的条数
        getEdgesCount();
        // 根据边条数，获取边的素组
        Edge[] edges = getEdgeArray();
        // 对边进行排序
        sortEdge(edges);
        // 用于存储最终最小生成树的结果
        ArrayList<Edge> result = new ArrayList<>();
        // end数组，用于存储已加入边的终点
        int[] end = new int[edgesCount];

        // 遍历已排序好的边数组
        for (int i = 0; i < edgesCount; i++) {
            // 获取该边的起始顶点和终止顶点
            int startIndex = getVertexIndex(edges[i].startVertex);
            int endIndex = getVertexIndex(edges[i].endVertex);

            // 获取起始顶点和终止顶点的终点
            int m = getEnd(end, startIndex);
            int n = getEnd(end, endIndex);

            // 如果终点不同，说明不形成回路，那么就将该边加入到结果list集合中
            // 并设置终点，如果终点相同，说明会形成回路，那么就遍历下一条边
            if (m!=n){
                result.add(edges[i]);
                end[m] = n;
            }
        }

        // 打印最小生成树的结果
        for (Edge edge : result) {
            System.out.println(edge);
        }
    }
}


// 边的类
class Edge{
    char startVertex; // 边的起始顶点
    char endVertex; // 边的终止顶点
    int weight; // 该边的权

    public Edge(char startVertex, char endVertex, int weight) {
        this.startVertex = startVertex;
        this.endVertex = endVertex;
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Edge{" +
                "startVertex=" + startVertex +
                ", endVertex=" + endVertex +
                ", weight=" + weight +
                '}';
    }
}

结果：

Edge{startVertex=E, endVertex=F, weight=2}
Edge{startVertex=C, endVertex=D, weight=3}
Edge{startVertex=D, endVertex=E, weight=4}
Edge{startVertex=B, endVertex=F, weight=7}
Edge{startVertex=E, endVertex=G, weight=8}
Edge{startVertex=A, endVertex=B, weight=12}

. 终点解释

边排序后，第一条边是<E,F>，起始顶点是E索引4，终止顶点是F索引是5，那么分别取获取终点，由于是第一条边，end数组每一个数据都是默认值0，所以进入getEnd方法返回的都是自己的索引，即m=4，n=5，由于m!=n，说明终点不一样，所以将该边加入到结果集中，然后将end[4]=5，意思是将E的终点设置成F，此时End数组：

根据for循环，判断第二条边<C,D>，起始顶点是C索引2，终止顶点是D索引是3，那么分别获取终点，进入getEnd方法，由于索引2和3的值都是0，返回依旧时各自的索引，即m=2，n=3，由于m!=n，说明终点不一样，所以将该边加入到结果集中，然后将end[2]=3，意思是将C的终点设置成D，此时End数组：

根据for循环，判断第三条边<D,E>，起始顶点是D索引3，终止顶点是E索引是4，那么分别获取终点，进入getEnd方法，由于索引3的值是0返回3，索引4的值是5返回5，即m=3，n=5，由于m!=n，说明终点不一样，所以将该边加入到结果集中，然后将end[3]=5，意思是将D的终点设置成F，此时End数组：

根据for循环，判断第四条边<C,E>，起始顶点是C索引2，终止顶点是E索引是4，那么分别获取终点，进入getEnd方法，由于索引2的值是3，while循环不等于0会继续判断，所以最终会找到值5，索引4的值是5返回5，即m=5，n=5，由于m==n，说明终点一样，会构成回路，所以会直接进入下一轮循环。

以此类推，获得最终结果。