常用的十大算法-克鲁斯卡尔算法（最小生成树问题、公交车站问题）

克鲁斯卡尔算法介绍

克鲁斯卡尔算法（kruskal），是用来求加权连通图的最小生成树的算法。
基本思想是，按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路。
具体做法是，首先构造一个只含n个顶点的森林，然后依权值从小到大从连通图中选择边加入到森林中，并使森林不产生回路，直到森林变成一棵树为止。

应用场景-公交车站问题

某城市新增7个站点（A,B,C,D,E,F,G），现在需要把7个站点连通，各个站点的距离用边表示（权），如何修路保证各个站点能够连通，并且总的修建公路总里程最短？

算法分析

问题一：如何对图的所有边按照权值大小排序？
问题二：将边添加到最小生成树中时，怎么判断是否形成了回路？
问题一很好解决，采用排序算法即可。
问题二，记录顶点在“最小生成树”中的终点，顶点的终点是在最小生成树中与它连通的最大顶点。然后每次需要将一条边添加到最小生成树中时，判断该边的两个顶点的终点是否重合，重合的话会形成回路。

关于终点的说明
1、就是将所有顶点按照从小到大的顺序排列好之后，某个顶点的终点就是与它连通的最大顶点。
2、例如，按照边的权值顺序依次添加到最小生成树中，依次是<E,F>,<C,D>,<D,E>,这三条边都不会形成回路，这几条边都添加成功后，这些边的顶点都有了共同的终点F，因此，当添加边<C,E>时，C,E的终点相同都为F，因此会形成回路。

代码如下

package algorithm;

/**
 * @author taoke
 * @desc 克鲁斯卡尔算法（公交车站问题）
 * @email 1504806660@qq.com
 * @date 2022/1/25
 */
public class Kruskal {

    /**
     * 边的个数
     */
    private static int edgeNum;

    /**
     * 顶点数栈
     */
    private static final char[] vertex = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};

    /**
     * 最大值
     */
    private static final int N = Integer.MAX_VALUE;

    /**
     * 结果数组
     */
    private static Edge[] result;

    /**
     * 邻接矩阵
     */
    private static final int[][] matrix = {
            {0, 12, N, N, N, 16, 14},
            {12, 0, 10, N, N, 7, N},
            {N, 10, 0, 3, 5, 6, N},
            {N, N, 3, 0, 4, N, N},
            {N, N, 5, 4, 0, 2, 8},
            {16, 7, 6, N, 2, 0, 9},
            {14, N, N, N, 8, 9, 0}
    };

    public Kruskal() {
        int len = vertex.length;
        //统计边
        for (int i = 0; i < len; i++) {
            for (int j = i + 1; j < len; j++) {
                if (matrix[i][j] != N) {
                    edgeNum++;
                }
            }
        }
        result = new Edge[edgeNum];
    }

    public static void main(String[] args) {
        //实例化对象
        Kruskal kruskal = new Kruskal();
        //获取所有的边
        Edge[] edges = getEdge();
        //对边进行排序
        kruskal.sortEdge(edges);
        kruskal.kruskal(edges);
        //打印结果
        kruskal.printResult();
    }

    /**
     * 克鲁斯卡尔算法
     */
    public void kruskal(Edge[] edges) {
        int index = 0;//表示结果数组的索引
        int[] ends = new int[edgeNum];//保存“已有最小生成树”中的每个顶点在最小生成树中的终点
        //遍历edges数组，每次添加边到最小生成树中时，判断待加入的边是否形成了回路,没有形成回路则加入到最小生成树中，否则继续遍历
        for (int i = 0; i < edgeNum; i++) {
            int p1 = getPosition(edges[i].start);//获取到第i条边的第一个顶点
            int p2 = getPosition(edges[i].end);//获取到第i条边的第二个顶点
            int m = getEnd(ends, p1);//获取p1这个顶点在已有的最小生成树中的终点
            int n = getEnd(ends, p2);//获取p2这个顶点在已有的最小生成树中的终点
            if (m != n) {//是否构成回路
                ends[m] = n;//设置m在“最小生成树”中的终点
                result[index++] = edges[i];//将这条边加入到结果中
            }
        }
    }

    /**
     * 对边进行排序
     *
     * @param edge 边的数组
     */
    private void sortEdge(Edge[] edge) {
        for (int i = 0; i < edge.length - 1; i++) {
            for (int j = 0; j < edge.length - 1 - i; j++) {
                if (edge[j].weight > edge[j + 1].weight) {
                    Edge temp = edge[j];
                    edge[j] = edge[j + 1];
                    edge[j + 1] = temp;
                }
            }
        }
    }

    /**
     * 从零阶矩阵中获取边的信息
     *
     * @return 边的数组
     */
    private static Edge[] getEdge() {
        int index = 0;
        Edge[] edges = new Edge[edgeNum];
        for (int i = 0; i < vertex.length; i++) {
            for (int j = i + 1; j < vertex.length; j++) {
                if (matrix[i][j] != N) {
                    edges[index++] = new Edge(vertex[i], vertex[j], matrix[i][j]);
                }
            }
        }
        return edges;
    }

    /**
     * 从顶点数组中获取指定字符的下标
     *
     * @param ch 顶点
     * @return 下标
     */
    private int getPosition(char ch) {
        for (int i = 0; i < vertex.length; i++) {
            if (vertex[i] == ch) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取下标为i的顶点的终点，用户后面判断两个顶点的重点是否相同
     *
     * @param ends 数组记录了各个顶点对应的终点是哪个，ends数组是在遍历的过程中，逐步形成
     * @param i    表示传入的顶点对应的下标
     * @return 返回的是下标为i的这个顶点的对应的终点的下标
     */
    private int getEnd(int[] ends, int i) {
        while (ends[i] != 0) {
            i = ends[i];
        }
        return i;
    }

    /**
     * 打印结果
     */
    public void printResult() {
        System.out.println("最小生成树为：");
        for (Edge edge : result) {
            if (null != edge) {
                System.out.println(edge);
            }
        }
    }

    /**
     * 边的实例对象
     */
    public static class Edge {
        /**
         * 边的一个点
         */
        char start;
        /**
         * 边的另一个点
         */
        char end;
        /**
         * 边的权值
         */
        int weight;

        public Edge(char start, char end, int weight) {
            this.start = start;
            this.end = end;
            this.weight = weight;
        }

        @Override
        public String toString() {
            return "< " + start +
                    " , " + end +
                    " = " + weight +
                    " >";
        }
    }

}

执行结果