大厂程序员必备十大基础算法 -- 克鲁斯卡尔算法

1. 克鲁斯卡尔算法

1.1 应用场景-公交站问题

看一个应用场景和问题：

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

1.2 最小生成树

在含有n个顶点的连通图中选择n-1条边，构成一棵极小连通子图，并使该连通子图中n-1条边上权值之和达到最小，则称其为连通网的最小生成树。

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

1.3 克鲁斯卡尔算法介绍

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

1.4 克鲁斯卡尔算法图解说明

以城市公交站问题来图解说明 克鲁斯卡尔算法的原理和步骤：
以上图G4为例，来对克鲁斯卡尔进行演示(假设，用数组R保存最小生成树结果)。

具体步骤如下：

• 第1步：将边加入R中。 边的权值最小，因此将它加入到最小生成树结果R中。
• 第2步：将边加入R中。 上一步操作之后，边的权值最小，因此将它加入到最小生成树结果R中。
• 第3步：将边加入R中。 上一步操作之后，边的权值最小，因此将它加入到最小生成树结果R中。
• 第4步：将边加入R中。上一步操作之后，边的权值最小，但会和已有的边构成回路；因此，跳过边。同理，跳过边。将边加入到最小生成树结果R中。
• 第5步：将边加入R中。
  上一步操作之后，边的权值最小，因此将它加入到最小生成树结果R中。
• 第6步：将边加入R中。 上一步操作之后，边的权值最小，但会和已有的边构成回路；因此，跳过边。同理，跳过边。将边加入到最小生成树结果R中。

此时，最小生成树构造完成！它包括的边依次是： 。

1.5 克鲁斯卡尔算法分析

根据前面介绍的克鲁斯卡尔算法的基本思想和做法，我们能够了解到，克鲁斯卡尔算法重点需要解决的以下两个问题：

• 问题一 对图的所有边按照权值大小进行排序。
• 问题二 将边添加到最小生成树中时，怎么样判断是否形成了回路。

问题一很好解决，采用排序算法进行排序即可。
问题二，处理方式是：记录顶点在"最小生成树"中的终点，顶点的终点是"在最小生成树中与它连通的最大顶点"。然后每次需要将一条边添加到最小生存树时，判断该边的两个顶点的终点是否重合，重合的话则会构成回路。

1.6 如何判断是否构成回路-举例说明(如图)

在将 加入到最小生成树R中之后，这几条边的顶点就都有了终点：

• (01) C的终点是F。
• (02) D的终点是F。
• (03) E的终点是F。
• (04) F的终点是F。

关于终点的说明：

1. 就是将所有顶点按照从小到大的顺序排列好之后；某个顶点的终点就是"与它连通的最大顶点"。
2. 因此，接下来，虽然是权值最小的边。但是C和E的终点都是F，即它们的终点相同，因此，将加入最小生成树的话，会形成回路。这就是判断回路的方式。也就是说，我们加入的边的两个顶点不能都指向同一个终点，否则将构成回路。

1.7 克鲁斯卡尔算法代码实现

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) {
		// TODO Auto-generated method stub
        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
       // kruskalCase.print();
      //   System.out.println(Arrays.toString(kruskalCase.getEdges()));
        EData[] edges = kruskalCase.getEdges();
        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 = 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++) {
				if (this.matrix[i][j] != INF) {
					edgeNum++;
				}
			}
		}
	}
	// 打印邻接矩阵
	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();
		}
	}
	/**
	 * 功能：对边进行排序处理，冒泡排序
	 * @param edges
	 */
	public 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;
				}
			}
		}
	}
	/**
	 * 
	 * @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;
			}
		}
		//找不到，返回-1
		return -1;
	}
	/**
	 * 功能：获取图中边，放到EData[]数组中，后面我们需要遍历该数组
	 * EData[] 形式[['A','B',12],['B','F',7],……]
	 * @return
	 */
	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){
					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的顶点在图中对应的终点下标
	 */
	public 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();
	    //排序
	    sortEdges(edges);
	    
	    //遍历edges数组，将边添加到最小生成树中时，判断是准备加入的边是否构成回路，如果没有就加入，否则不能加入
	    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);
	    	int n = getEnd(ends, p2);
	    	//是否构成回路
	    	if( m != n ){//没有构成回路
	    		ends[m] = n;
	    	    rets[index++] = edges[i];
	    	}
	    }
	    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;
	}
	@Override
	public String toString() {
		return "EData [<" + start + "," + end + ">=" + weight + "]";
	}
	
}

执行结果如下：