标签：int Kruskal 克鲁斯 ++ 算法 edges EData 顶点 INF

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个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止

克鲁斯卡尔算法重点需要解决的以下两个问题：

1. 对图中所有边按照权值大小进行排序
2. 将边添加到最小生成树中时，怎样判断是否形成了回路。

上述两个问题的解决办法

1. 采用排序算法进行排序即可；
2. 记录顶点在“最小生成树"中的终点，顶点的终点是“在最小生成树中与它联通的最大顶点”。然后每次需要将一条边添加到最小生成树时，判断该边的两个顶点的终点是否重合，重合的话则会构成回路。加入的边的两个顶点不能都指向同一个终点，否则将构成回路。

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.代码结构图

标签：int,Kruskal,克鲁斯,++,算法,edges,EData,顶点,INF
来源： https://www.cnblogs.com/y-tao/p/16651634.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。