克鲁斯卡尔(Kruskal)算法
1.应用场景-公交站问题
1)某城市新增7个站点(A, B, C, D, E, F, G) ，现在需要修路把7个站点连通
2)各个站点的距离用边线表示(权) ，比如 A – B 距离 12公里
3)问：如何修路保证各个站点都能连通，并且总的修建公路总里程最短?
2.克鲁斯卡尔算法介绍
1)克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。
2)基本思想：按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路
3)具体做法：首先构造一个只含n个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止
克鲁斯卡尔算法重点需要解决的以下两个问题：
- 对图中所有边按照权值大小进行排序
- 将边添加到最小生成树中时，怎样判断是否形成了回路。
上述两个问题的解决办法
- 采用排序算法进行排序即可；
- 记录顶点在“最小生成树"中的终点，顶点的终点是“在最小生成树中与它联通的最大顶点”。然后每次需要将一条边添加到最小生成树时，判断该边的两个顶点的终点是否重合，重合的话则会构成回路。加入的边的两个顶点不能都指向同一个终点，否则将构成回路。
3.克鲁斯卡尔代码实现
package com.yt.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 = new KruskalCase(vertexs, matrix);
// 输出
kruskalCase.print();
/*
EData[] edges = kruskalCase.getEdges();
// [EData [start=A, end=B, weight=12], EData [start=A, end=F, weight=16], EData [start=A, end=G, weight=14],。。。。。
System.out.println("排序前=" + Arrays.toString(edges));//未排序
kruskalCase.sortEdges(edges);
//排序后=[EData [start=E, end=F, weight=2], EData [start=C, end=D, weight=3], EData [start=D, end=E, weight=4]...
System.out.println("排序后=" + Arrays.toString(edges));
*/
kruskalCase.kruskal();
}
// 构造器
public KruskalCase(char[] vertxs, int[][] matrix) {
// 初始化顶点数和边的个数
int vlen = vertxs.length;
// 初始化顶点，复制拷贝的方式
this.vertexs = new char[vlen];
for (int i = 0; i < vlen; i++) {
this.vertexs[i] = vertxs[i];
}
// 初始化边，复制拷贝的方式
this.matrix = new int[vlen][vlen];
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 = i+1; j < vlen; j++) {//注意j的取值，除去统计自己
if (this.matrix[i][j] != INF) {
edgeNum++;
}
}
}
}
// 打印邻接矩阵
public void print() {
System.out.println("邻接矩阵为：\n");
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();
}
}
/**
* 功能：对边进行排序处理，冒泡排序
*
* @param edges
* 边的集合
*/
private void sortEdges(EData[] edges) {
EData temp;
boolean flag = false;// 默认表示不需要再比较
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) {
flag = true;// 有比较，修改标志位
temp = edges[j];
edges[j] = edges[j+1];
edges[j+1] = temp;
}
}
if (!flag) {
break;//没有比较之后，退出循环
} else {
flag = true;
}
}
}
/**
*
* @param ch 顶点的值，比如“A”，“B”。。。
* @return 返回ch顶点对应的下标，如果找不到，返回-1
*/
private int getPosition(char ch){
for(int i=0; i<vertexs.length; i++){
if (vertexs[i] == ch) {
return i;
}
}
return -1;
}
/**
* 功能：获取图中边，放到EDate[]数组中，后面我们需要遍历该数组
* 是通过matrix邻接矩阵来获取
*
* @return EData[] 形式：[['A','B',12],['B','F',7],......]
*/
private EData[] getEdges(){
int index = 0;
EData[] edges = new EData[edgeNum];
for(int i=0; i<vertexs.length; i++){
for(int j=i+1; j<vertexs.length; j++){
if (matrix[i][j] != INF) {
edges[index++] = new EData(vertexs[i], vertexs[j], matrix[i][j]);
}
}
}
return edges;
}
//难点
/**
* 功能：获取下标为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 kruskal(){
int index=0;//表示最后结果数组的索引
int[] ends = new int[edgeNum];//用于保存“已有最小生成树”中的每个顶点在最小生成树中的终点
//创建结果数组，保存最后的最小生成树
EData[] rets = new EData[edgeNum];
//获取图中所有边的集合
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条边的第2个顶点
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在“已有最小生成树”中的终点
rets[index++] = edges[i];//有一条边加入到rets数组
}
}
//统计并打印“最小生成树”，输出rets
System.out.println("最小生成树为：");
for(int i=0; i<index; i++){
System.out.println(rets[i]);
}
}
}
// 创建一个类，EData，它的对象实例就表示一条边
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;
}
// 重写toString方法
@Override
public String toString() {
return "EData [<" + start + ", " + end + ">= " + weight + "]";
}
}
4.测试结果
5.代码结构图
