Kruskal算法求最小生成树

测试数据：
5 6
0 1 5
0 2 3
1 2 4
2 4 2
2 3 1
1 4 1

输出：
2 3 1
1 4 1
2 4 2
0 2 3

思路：在保证不产生回路的情况下，选择权值小的边。是否产生回路采用并查集来实现

判断两个点是否连通：如果两个点的祖先不是同一个，说明这两个点不可联通，要标志两个点联通，只要使两个点的祖先是同一个。关于并查集的讲解可以看我转载的一篇文章。

比如初始化的时候ABC的祖先是他自己，先加入了AB这条边，这两个点的的父亲不一样，可以加入这条边，同时将A的祖先设置为B的祖先。同样AC加入也是这样，将C的父亲设为A的祖先B。这时候发现ABC相互可达，他们的祖先都是一个B。这个时候如果要添加BC这条边，查看BC的祖先，发现祖先一样，说明这两个点是可达的，那么如果添加这条边就会产生回路。

总的来说，将相邻的边所有顶点的祖先设置为同一个，如果两个顶点的祖先是同一个，那么就表明这两个点是可达的。那么如果还要添加这个以这两个顶点为顶点的边，就会产生回路。

import java.io.BufferedReader;
import java.io.FileReader;
public class Kruskal {
	static int father[];
	static Edge edges[];
	static Edge tree[];
	static int verNum,edgeNum;
	public static void main(String[] args) throws Exception {
		
		readData();
		initFather();
		getTree();
	}
	/**
	 * 读取文本的数据
	 * @throws Exception
	 */
	private static void readData()throws Exception {
		// TODO 自动生成的方法存根
		BufferedReader bf=new BufferedReader(new FileReader("d:/testGraphic.txt"));
		String strings[]=bf.readLine().split(" ");
		verNum=Integer.parseInt(strings[0]);
		edgeNum=Integer.parseInt(strings[1]);
		edges=new Edge[edgeNum];
		tree=new Edge[verNum-1];
		for (int i = 0; i < edgeNum; i++) {
			strings=bf.readLine().split(" ");
			edges[i]=new Edge(Integer.parseInt(strings[0]),Integer.parseInt(strings[1]),Integer.parseInt(strings[2]));
		}
		sort();
		bf.close();
	}
	/**
	 * 将各条边按照权值从小到大进行排列
	 */
	public static void sort()
	{
		for (int i = 0; i < edges.length; i++) {
			for (int j = i+1; j < edges.length; j++) {
				if(edges[j].weight<edges[i].weight)
				{
					Edge temp=edges[j];
					edges[j]=edges[i];
					edges[i]=temp;
				}
			}
		}
	}
	/**
	 * 初始化每个点的父亲设置为自己
	 */
	private static void initFather() {
		// TODO 自动生成的方法存根
		father=new int[verNum];
		for (int i = 0; i < father.length; i++) {
			father[i]=i;
		}
	}
	/**
	 * 获得最小生成树
	 */
	private static void getTree() {
		// TODO 自动生成的方法存根
		int edgesIndex=0;
		int treeIndex=0;
		while(true)
		{
			//如果边数够了跳出循环
			if(treeIndex==verNum-1)
				break;
			int father1=findFather(edges[edgesIndex].from);
			int father2=findFather(edges[edgesIndex].end);
			//如果两个的点的父亲不相同 则说明不连通
			if(father1!=father2)
			{
				tree[treeIndex++]=edges[edgesIndex];
				
				father[father1]=father2;
			}
			edgesIndex++;
		}
		//输出树
		printTree();
	}
	private static void printTree() {
		// TODO 自动生成的方法存根
		for (int i = 0; i < tree.length; i++) {
			Edge edge=tree[i];
			System.out.println(edge);
		}
	}
	
	/**
	 * 查找一个点的父亲
	 * @param i
	 * @return
	 */
	public static int findFather(int i)
	{
		//如果一个点的父亲是自己 返回
		if(father[i]==i)
			return i;
		//否则一直查找他的顶层。
		else
		{
			int f=i;
			while(father[f]!=f)
			{
				f=father[f];
			}
			
			father[i]=father[f];
			return father[f];
		}
	}
	
}
class Edge
{
	public int from;
	public int end;
	public int weight;
	public Edge(int from,int end,int weight)
	{
		this.from=from;
		this.end=end;
		this.weight=weight;
	}
	public String toString()
	{
		return this.from+" "+this.end+" "+this.weight;
	}
}

prim算法求最小生成树

思路：先随机找一个点添加到点集U中，在V-U中找一个点与U点集中关联并且权值最小的点，然后将这个点添加到点集U中，依次下去，直至U==V

测试数据：
5 6
0 2 3
1 2 4
2 4 2
2 3 1
1 4 1

输出：
0 2 3
2 3 1
2 4 2
4 1 1

import java.io.BufferedReader;
import java.io.FileReader;
public class Prime {
	static int array[][];
	static int verNum,edgeNum;
	/**
	 * 读取文本数据
	 * @throws Exception
	 */
	public static void readData() throws Exception
	{
		BufferedReader bf=new BufferedReader(new FileReader("d:/testGraphic.txt"));
		String strings[]=bf.readLine().split(" ");
		verNum=Integer.parseInt(strings[0]);
		edgeNum=Integer.parseInt(strings[1]);
		array=new int [verNum][verNum];
		//用矩阵表示两个点之间的权值，如果是相同点标志为0 如果两个点不关联设为100
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length; j++) {
				if(i==j)
					array[i][j]=0;
				else
					array[i][j]=100;
			}
		}
		
		//根据文本进行赋值
		for (int i = 0; i < edgeNum; i++) {
			strings=bf.readLine().split(" ");
			int a=Integer.parseInt(strings[0]);
			int b=Integer.parseInt(strings[1]);
			int c=Integer.parseInt(strings[2]);
			array[a][b]=c;
			array[b][a]=c;
		}
			
	}
	/**
	 * 打印生成最小树
	 * @param tree
	 */
	public static void printTree(int tree[][])
	{
		for(int a[]:tree)
		{
			for(int b:a)
			{
				System.out.print(b+" ");
			}
			System.out.println();
		}
	}
	public static void main(String[] args) throws Exception 
	{
		readData();
		//创建最小生成树
		int tree[][]=new int [verNum-1][3];
		
		//取一个点放到点集U
		int k=0;
		
		CloseEdge edge[]=new CloseEdge[verNum];
		//其他点和点K的权值
		for (int i = 0; i < verNum; i++) {
			edge[i]=new CloseEdge(k,array[k][i]);
		}
		edge[k]=new CloseEdge(k,0);
		
		//执行次数为边的数量
		for (int o = 0; o< verNum-1; o++) 
		{
			int min=Integer.MAX_VALUE;
			//在V-U中的点中找一个和U中点关联的并且权值最小的加入到U
			for (int i = 0; i <verNum; i++) {
				if(edge[i].weight!=0&&edge[i].weight<min)
				{
					min=edge[i].weight;
					k=i;
				}
			}
			//将新选取点的权值存到数中
			tree[o][2]=edge[k].weight;
			//设置选中的点到U的权值为0，表示已经在U中
			edge[k].weight=0;
			
			//将新增加的变记录下来，第0个点是与新顶点相关联的的点，第一个顶点是新的顶点
			tree[o][0]=edge[k].index;
			tree[o][1]=k;
			
			
			
			//因为有新顶点加入，所以重新设置V-U与点集U中点关联的最小的权值
			for (int i = 0; i < edge.length; i++) {
				if(array[k][i]<edge[i].weight)
					edge[i]=new CloseEdge(k,array[k][i]);
			}
		}
		printTree(tree);
		
		
	}
}
class CloseEdge
{
	
	
	
	int index;
	int weight;
	/**
	 * 
	 * @param index
	 * @param weight
	 */
	public CloseEdge(int index,int weight)
	{
		this.index=index;
		this.weight=weight;
	}
}