理论：
Prim：
基本思想：假设G＝(V，E)是连通的，TE是G上最小生成树中边的集合。算法从U＝{u0}（u0∈V）、TE＝{}开始。重复执行下列操作：
在所有u∈U，v∈V－U的边(u，v)∈E中找一条权值最小的边(u0,v0)并入集合TE中，同时v0并入U，直到V＝U为止。
此时，TE中必有n-1条边，T=(V，TE)为G的最小生成树。
Prim算法的核心:始终保持TE中的边集构成一棵生成树。
Kruskal：
假设连通网N＝（V，{E}）。则令最小生成树的初始状态为只有n个顶点而无边的非连通图T＝（V，{}），图中每个顶点自成一个连通分量。
在E中选择最小代价的边，若该边依附的顶点落在T中不同的连通分量中，则将该边加入到T中，否则舍去此边而选择下一条代价最小的边，依次类推，直到T中所有顶点都在同一连通分量上为止。
两者比较；
prim算法适合稠密图，其时间复杂度为O(n^2)，其时间复杂度与边得数目无关，而kruskal算法的时间复杂度为O(eloge)跟边的数目有关，适合稀疏图。
java实现
Vertex.java
package 图;
public class Vertex{
String value;
boolean isVisited;
Vertex(String value)
{
this.value=value;
this.isVisited=false;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public boolean isVisited() {
return isVisited;
}
public void setVisited(boolean isVisited) {
this.isVisited = isVisited;
}
}
Edge.java
package 图;
public class Edge{
Vertex start;
Vertex end;
int value;
public Vertex getStart() {
return start;
}
public void setStart(Vertex start) {
this.start = start;
}
public Vertex getEnd() {
return end;
}
public void setEnd(Vertex end) {
this.end = end;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
Edge(Vertex start,Vertex end, int value){
this.start=start;
this.end=end;
this.value=value;
}
}
Graph.java
package 图;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
public class Graph {
public static List<Vertex> vertexList=new ArrayList<Vertex>();
public static List<Edge> EdgeQueue=new ArrayList<Edge>();
public static List<Vertex> newVertex=new ArrayList<Vertex>();
public static List<Edge> newEdge=new ArrayList<Edge>();
public static void buildGraph(){
Vertex a=new Vertex("a");
vertexList.add(a);
Vertex b=new Vertex("b");
vertexList.add(b);
Vertex c=new Vertex("c");
vertexList.add(c);
Vertex d=new Vertex("d");
vertexList.add(d);
Vertex e=new Vertex("e");
vertexList.add(e);
Vertex f=new Vertex("f");
vertexList.add(f);
addEdge(a, b, 3);
addEdge(a, e, 6);
addEdge(a, f, 5);
addEdge(b, a, 3);
addEdge(b, c, 1);
addEdge(b, f, 4);
addEdge(c, b, 1);
addEdge(c, d, 6);
addEdge(c, f, 4);
addEdge(d, c, 6);
addEdge(d, f, 5);
addEdge(d, e, 8);
addEdge(e, d, 8);
addEdge(e, f, 2);
addEdge(e, a, 6);
addEdge(f, a, 5);
addEdge(f, b, 4);
addEdge(f, c, 4);
addEdge(f, d, 5);
addEdge(f, e, 2);
}
public static void addEdge(Vertex start,Vertex end,int value){
Edge e=new Edge(start,end,value);
EdgeQueue.add(e);
}
public static boolean containVertex(Vertex v){
for(Vertex each:newVertex)
{
if(each.value.equals(v.value))
return true;
}
return false;
}
public static void prim(){
buildGraph();
Vertex start=vertexList.get(0);
newVertex.add(start);
for(int i=0; i<vertexList.size(); i++)
{
Vertex temp=new Vertex(start.value);
Edge tempEdge=new Edge(start, start, 1000);
for(Vertex v:newVertex)
{
for(Edge e:EdgeQueue)
{
if(e.start==v && !containVertex(e.end))
{
if(tempEdge.value>e.value)
{
tempEdge=e;
temp=e.end;
}
}
}
}
newVertex.add(temp);
}
Iterator<Vertex>i=newVertex.iterator();
while(i.hasNext())
{
Vertex v=i.next();
System.out.print(v.value+" ");
}
}
public static void kruskal(){
buildGraph();
sort();
}
public static void sort(){
Comparator<Edge>comparator=new Comparator<Edge>(){
@Override
public int compare(Edge e1, Edge e2) {
// TODO Auto-generated method stub
return e1.getValue()-e2.getValue();
}
};
Collections.sort(EdgeQueue,comparator);
}
public static void main(String[] args) {
prim();
}
}
