程序员必须会的基本算法7-Kruskal算法(库拉斯卡尔算法)

Kruskal算法

首先了解这个算法是用来干嘛的
求最小生成树的算法主要是普里姆算法和克鲁斯卡尔算法,所以它和prim算法一样是用来用最小生成树的
克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。
基本思想：按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路

问题背景

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

解决

Kruskal算法的思路是这样的,
首先它是将所有的边按照权重从小到大进行了排序
然后从排序好的边中一条一条地选择加入到最小生成树中
第一步
选到的是E-F(2),判断有没有构成回路,因为E,F刚开始的顶点都是自己,所以没有构成回路,可以直接加入最小生成树数组中,设置E的顶点是F
第二步
选到的是C-D(3),C,D的顶点还是都是自己,直接加入,C的顶点是D
第三步
选的是D-E(4)边,D的顶点是D,E的顶点是F,直接加入,设置D的顶点是E
第四步
选择C-E,C的顶点是D,D的是E,E的是F,所以C的最终顶点是F,E的顶点也是F,构成回路,不能加入
下面的都差不多了,一直将所有的边都遍历一次,最小生成树就构建完成

代码解决

package basic;

import java.util.Arrays;

public class Kruskal
{
	//number表示边的个数
	public static int number;
	public static char[] nodes;
	public static final int INF=Integer.MAX_VALUE;
	public static int[][] weight;
	
 	public static void main(String[] args)
	{
 		weight= new int[][]{
 					/*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}}; 
 		nodes=new char[] {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
 		kruskal(nodes, weight);
 		
	}
 	
 	public static void InitNumber()
 	{
 		for(int x=0;x<nodes.length;x++)
 		{
 			for(int y=x+1;y<nodes.length;y++)
 			{
 				if(weight[x][y]!=INF)
 				{
 					number++;
 				}
 			}
 		}
 	}
 	public static void kruskal(char[] nodes,int[][] weight)
 	{
 		//初始化number
 		InitNumber();
 		
 		//返回结果的索引index,和保存结果的数组result
 		int index=0;
 		Edge[] result=new Edge[nodes.length-1];
 		
 		//用于保存每一个节点在最小生成树中的结尾是什么
 		int[] ends=new int[number];	
 		
 		//然后想的是获取所有的边,然后将所有的边进行排序
 		Edge[] edges = getEdges();
 		Sort(edges);
 		
 		//然后是判断每一条边看看是否是需要加入到最小生成树上面的
 		for(int x=0;x<number;x++)
 		{
 			//然后现在想判断的是这条边的两个节点的顶点是不是同一个顶点
 			int end1 = GetEnd(ends, edges[x].start);
 			int end2 = GetEnd(ends, edges[x].end);
 			if(end1!=end2)
 			{
 				ends[end1]=end2;
 				result[index++]=edges[x];
 			}
 		}
		System.out.println("最小生成树为");
		for(int i = 0; i < index; i++) {
			System.out.println(result[i]);
		}
 	}
 	public static int GetEnd(int[] ends,char node)
 	{
 		int index=-1;
 		for(int x=0;x<nodes.length;x++)
 		{
 			if(nodes[x]==node)
 			{
 				index=x;
 				break;
 			}
 		}
 		while(ends[index]!=0)
 		{
 			index=ends[index];
 		}
 		return index;
 	}
 	
 	public static void Sort(Edge[] edges)
 	{
 		System.out.println("前:"+Arrays.toString(edges));
 		for(int x=0;x<edges.length-1;x++)
 		{
 			for(int y=0;y<edges.length-1-x;y++)
 			{
 				if(edges[y].weight>edges[y+1].weight)
 				{
 					Edge temp=edges[y];
 					edges[y]=edges[y+1];
 					edges[y+1]=temp;
 				}
 			}
 		}
 		System.out.println("后:"+Arrays.toString(edges));
 	}
 	
 	public static Edge[] getEdges()
 	{
 		int index=0;
 		Edge[] edges=new Edge[number];
 		for(int x=0;x<nodes.length;x++)
 		{
 			for(int y=x+1;y<nodes.length;y++)
 			{
 				if(weight[x][y]!=INF)
 				{
 					edges[index++]=new Edge(nodes[x], nodes[y], weight[x][y]); 					
 				}
 			}
 		}
 		return edges;
 	}
}
/*
 * 类Edge表示一条边,保存了start(边的开头字母),end(边的结尾字母),weight(边的权重)
 */
class Edge
{
	char start;
	char end;
	int weight;
	public Edge(char start, char end, int weight)
	{
		this.start = start;
		this.end = end;
		this.weight = weight;
	}
	@Override
	public String toString()
	{
		return "<" + start + "," + end + ">=" + weight;
	}
}