克鲁斯卡尔(Kruskal)算法

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

public class Kruskal {
    private static final int INF = Integer .MAX_VALUE;
    public static void main(String[] args) {
        //克鲁斯卡尔算法的邻接矩阵
        int matrix[][] = {
            { 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}};

        int[] ends = new int[matrix.length]; //存储选中的边的顶点对应的终点，数组下标是顶点，数组元素是终点
        int sum = 0; //存储结果
        Edge[] edges = new Edge[12]; //存储有效边的顶点和权值
        int index = 0;

        //初始化边集
        for (int i = 0; i < matrix.length; i++){
            for (int j = i + 1; j < matrix.length; j++){
                if (matrix[i][j] < INF){
                    edges[index++] = new Edge(i, j, matrix[i][j]);
                }
            }
        }

        //对边集排序
        Arrays.sort(edges);

        for (int i = 0; i < edges.length; i++){
            Edge temp = edges[i];
            int m = getEnd(ends, temp.start);
            int n = getEnd(ends, temp.end);
            if (m != n){
                ends[m] = n; //连接森林成树
                sum += temp.weight;
            }
        }
        System.out.println(sum);
    }

    /**
     *
     * @param ends 存储每个顶点对应的终点
     * @param i 顶点下标
     * @return 终点下标
     */
    public static int getEnd(int[] ends, int i){

        //ends[i] != 0说明i的终点不是自己，就令i等于它的终点ends[i],直到ends[i] = 0,i是最终的终点
        while(ends[i] != 0){
            i = ends[i];
        }

        return i;
    }
}

class Edge implements Comparable<Edge>{
    int start;
    int end;
    int weight;
    public Edge(int start, int end, int weight){
        this.start = start;
        this.end = end;
        this.weight = weight;
    }

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