数据结构和算法:程序员常用的10种算法之克鲁斯卡尔算法

应用场景-公交站问题

看一个应用场景和问题：

1）某城市新增7个站点（A,B,C,D,E,F,G）,现在需要修路把7个站点连通
2）各个站点的距离用边线表示（权），比如A---->B距离12公里；
3）问：如何修路保证各个站点都能连通，并且总的修路公路总里程最短？

克鲁斯卡尔算法介绍

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

克鲁斯卡尔算法图解说明

以城市公交站问题来图解说明，克鲁斯卡尔算法的原理和步骤：
在含有n个顶点的连通图中选择n-1条边，构成一颗极小连通子图，并使该连通子图中n-1条边上权值之和达到最小，则称其为连通网的最小生成树；

例如，对于如上图G4所示的连通网可以有多颗权值总和不相同的生成树。

图解：

公交站问题代码实现

package com.atschool.kruskal;

import java.util.Arrays;

public class KruskalCase {
    private int edgeNum; //边的个数
    private char[] vertexs; //顶点数组
    private int[][] matrix; //邻接矩阵
    //使用 INF 表示两个顶点不能连通
    private static final int INF = Integer.MAX_VALUE;
    public static void main(String[] args) {
        char[] vertexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        //克鲁斯卡尔算法的邻接矩阵
        int matrix[][] = {
                /*A*//*B*//*C*//*D*//*E*//*F*//*G*/
                /*A*/ {   0,  12, INF, INF, INF,  16,  14},
                /*B*/ {  12,   0,  10, INF, INF,   7, INF},
                /*C*/ { INF,  10,   0,   3,   5,   6, INF},
                /*D*/ { INF, INF,   3,   0,   4, INF, INF},
                /*E*/ { INF, INF,   5,   4,   0,   2,   8},
                /*F*/ {  16,   7,   6, INF,   2,   0,   9},
                /*G*/ {  14, INF, INF, INF,   8,   9,   0}};
        //大家可以在去测试其它的邻接矩阵，结果都可以得到最小生成树.

        //创建KruskalCase 对象实例
        KruskalCase kruskalCase = new KruskalCase(vertexs, matrix);
        //输出构建的
        //kruskalCase.print();
        kruskalCase.kruskal();

    }
    //构造器
    public KruskalCase(char[] vertexs,int[][] matrix){
        //初始化顶点数和边的个数
        int vlen = vertexs.length;
        //初始化顶点，复制拷贝的方式
        this.vertexs =new char[vlen];
        for (int i = 0; i < vertexs.length; i++) {
            this.vertexs[i]  = vertexs[i];
        }
        //初始化边，使用的是复制拷贝的方式
        this.matrix =matrix;
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
            this.matrix[i][j] = matrix[i][j];

            }

        }
        //统计边的条数
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
                if(this.matrix[i][j] != INF){
                    edgeNum++;
                }
            }
        }



    }
    //Kruskal算法实现
    public void kruskal(){
        int index =0;//表示最后结果数组的索引
        int[] ends = new int[edgeNum];//用于保存"已有最小生成树"中的每个顶点在最小生成树中的终点
        //创建结果数组，保存最后的最小生成树
        EData[] rets = new EData[edgeNum];
        //获取图中所有的边的集合，一共有12边
        EData[] edges =getEdges();
        System.out.println("图的边的集合=" + Arrays.toString(edges)+ "共" +edges.length);
        //按照边的权值大小进行排序（从小到大）
        sortEdges(edges);
        //遍历edges数组，将边添加到最小生成树中时，判断准备加入的边是否形成了回路，如果没有，就加入rets,否则不能加入
        for (int i = 0; i < edgeNum; i++) {
            //获取到第i条边的第一个顶点（起点）
            int p1 = getPosition(edges[i].start);
            //获取到第i条边的第二个顶点（终点）
            int p2 =getPosition(edges[i].end);

            //获取p1这个顶点在已有最小生成树中的终点
            int m =getEnd(ends,p1);
            //获取p2这个顶点在已有最小生成树中的终点
            int n = getEnd(ends,p2);
            //是否构成回路
            if(m != n){//没有构成回路
                ends[m] = n;//设置m在已有最小生成树中的终点<E,F> [0,0,0,0,5,0,0,0,0,0,0,0]
                rets[index++] = edges[i];//有一条边加入到rets数组
            }
        }

        System.out.println("最小生成树");
        for (int i = 0; i < index; i++) {
            System.out.println(rets[i]);
        }
    }


    //打印邻接矩阵
    public void print(){
        System.out.println("邻接矩阵为：");
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = 0; j < vertexs.length; j++) {
                System.out.printf("%12d",matrix[i][j]);

            }
            System.out.println();//换行

        }
    }
    //对边进行排序处理，冒泡排序
    private void sortEdges(EData[] 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) {//交换
                    EData tmp = edges[j];
                    edges[j] = edges[j+1];
                    edges[j+1] = tmp;
                }
            }
        }
    }
    //返回ch顶点对应的下标，如果找不到，返回-1
    private int  getPosition(char ch){
        for (int i = 0; i < vertexs.length; i++) {
            if(vertexs[i] == ch){
                return i;
            }
        }
        //找不到，返回-1
        return -1;
    }
    //获取图中边，放到Edata[]数组中，后面我们需要遍历该数组
    private EData[] getEdges(){
        int index=0;
        EData[] edges = new EData[edgeNum];
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = 0; j < vertexs.length; j++) {
                if(matrix[i][j] !=INF ){
                    edges[index++] =new EData(vertexs[i],vertexs[j],matrix[i][j]);
                }
            }
        }
        return edges;
    }
    //获取下标为i的顶点的终点，用于后面判断两个顶点的终点是否相同
    private int getEnd(int[] ends,int i){
        while(ends[i] !=0){
            i=ends[i];
        }
        return i;
    }





}




class EData{
    char start;//边的一个点
    char end ;//边的另外一个点
    int weight;//边的权值
    //构造器
    public EData(char start,char end,int weight){
        this.start=start;
        this.end =end;
        this.weight =weight;

    }

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