最小生成树：Kruskal算法 和 Prim算法（第23章）

武侠： 飞雪连天射白鹿，笑书神侠倚碧鸳。 ——金庸十四著作

飞狐外传 、雪山飞狐 、连城诀 、天龙八部 、射雕英雄传 、白马啸西风 、鹿鼎记 、笑傲江湖 、书剑恩仇录 、神雕侠侣 、侠客岛 、倚天屠龙记 、碧血剑 、鸳鸯刀 （除此之外还缺少越女剑）。

声明:本文参考了华山大师兄博客最小生成树-Prim算法和Kruskal算法。结合自己学习《算法导论》的认识形成的笔记。感谢网友的总结分享。

1. 最小生成树的生成

　　一个带权的无向连通图,如何选取一棵生成树,使树上所有边上权的总和为最小,这叫最小生成树。Kruskal算法 和 Prim算法都是使用贪心策略来解决最小生成树的问题。

//无相连通图G(V,E)和权重函数w:E->R.
Generic-MST(G,w){
A=Φ;//Φ表示空集
while(A does not from a spinning tree){
find a edge(u,v) that is safe for A;
A=A∪{(u,v)}
}
return A;
}

2. 克鲁斯卡尔算法

算法思想：遍历根据权重从小到大排序的边，依据约束，合并森林成为目标树。（自己理解的大白话）

1).记Graph中有v个顶点，e个边。

2).新建图Graphnew，Graphnew中拥有原图中相同的v个顶点，但没有边。

3).将原图Graph中所有e个边按权值从小到大排序

4).循环：从权值最小的边开始遍历每条边 直至图Graph中所有的节点都在同一个连通分量中

if 这条边连接的两个节点于图Graphnew中不在同一个连通分量中

添加这条边到图Graphnew中

3. 普里姆算法

算法思想：从一点出发，先添加连通的最近的结点，一直到所有的几点都包含在目标树中。（自己理解的大白话）

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空；

3).重复下列操作，直到Vnew = V：

　　a.在集合E中选取权值最小的边

4. 算法Java实现**

4.1 图的存储和表示

package lbz.ch23.mst;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
* @author LbZhang
* @version 创建时间：2016年3月16日 下午9:11:24
* @description 图
*/
public class Graph {

public final static int NODECOUNT = 9;
public final static String[] VERTEXS={"a","b","c","d","e","f","g","h","i"};
private final int[][] EDGEVALUE = {
{ 0, 4, 0, 0, 0, 0 , 0 ,8, 0},
{ 4, 0, 8, 0, 0, 0 , 0 ,11, 0},
{ 0, 8, 0, 7, 0, 4 , 0 ,0, 2},
{ 0, 0, 7, 0, 9, 14, 0 ,0, 0},
{ 0, 0, 0, 9, 0, 10, 0 ,0, 0},
{ 0, 0, 4, 14, 10, 0, 2 ,0, 0},
{ 0, 0, 0, 0, 0, 2, 0 ,1, 6},
{ 8, 11, 0, 0, 0, 0, 1 ,0, 7},
{ 0, 0, 2, 0, 0, 0, 6 ,7, 0}

};

public int count;
public String[] vertexstr;
public int[][] edgesValue;

public Graph() {
this.count=NODECOUNT;
this.edgesValue=EDGEVALUE;
this.vertexstr=VERTEXS;
}
/**
* 获取当前图中的所有的边集合
* @return
*/
public List<FromTo> getSortedEdgeFromTo(){
List<FromTo> fts = new ArrayList<FromTo>();
for(int i=0;i<NODECOUNT;i++){
for(int j=0;j<=i;j++){
if(this.edgesValue[i][j]!=0){
FromTo ft = new FromTo();
ft.setFrom(new TreeNode(this.vertexstr[i]));
ft.setTo(new TreeNode(this.vertexstr[j]));
ft.setWeight(this.edgesValue[i][j]);
fts.add(ft);
}
}
}
ComparatorFromTo cft = new ComparatorFromTo();
Collections.sort(fts, cft);
//      for(int i=0;i<fts.size();i++){
//          System.out.print(fts.get(i).weight+"  ");
//      }
//      System.out.println();
return fts;
}

public int getCount() {
return count;
}

public void setCount(int count) {
this.count = count;
}

public String[] getVertexstr() {
return vertexstr;
}

public void setVertexstr(String[] vertexstr) {
this.vertexstr = vertexstr;
}

public int[][] getEdgesValue() {
return edgesValue;
}

public void setEdgesValue(int[][] edgesValue) {
this.edgesValue = edgesValue;
}

/**
* 图的链接矩阵表示的输出打印
*/
public void printMGraph() {
System.out.print("  ");//这里的间隙使用的是tab 制表键
for(int i=0;i<this.count;i++){
System.out.print(this.vertexstr[i] + "  ");
}
System.out.println();
for (int i = 0; i < this.edgesValue[0].length; i++) {
System.out.print(this.vertexstr[i] + "  ");
for (int j = 0; j < this.edgesValue[0].length; j++) {
System.out.print(this.edgesValue[i][j] + "  ");
}
System.out.println();
}

System.out.println("------------图的链接矩阵表示的输出打印结束------------");
}

/**
* 类内测试函数
* @param args
*/
public static void main(String[] args) {
Graph g = new Graph();
g.printMGraph();
}

}

4.2 树的存储和表示

package lbz.ch23.mst;

import java.util.Comparator;

import sun.misc.Compare;

/**
* @author LbZhang
* @version 创建时间：2016年3月17日 上午5:41:52
* @description 边类
*/
public class FromTo{

public int weight;
public TreeNode from;
public TreeNode to;

@Override
public String toString() {

return this.from.getVetex()+"->"+this.getTo().getVetex()+":"+this.weight+"";
}

public FromTo() {
super();
}

public FromTo(int weight, TreeNode from, TreeNode to) {
super();
this.weight = weight;
this.from = from;
this.to = to;
}

public int getWeight() {
return weight;
}

public void setWeight(int weight) {
this.weight = weight;
}

public TreeNode getFrom() {
return from;
}

public void setFrom(TreeNode from) {
this.from = from;
}

public TreeNode getTo() {
return to;
}

public void setTo(TreeNode to) {
this.to = to;
}
}

package lbz.ch23.mst;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
* @author LbZhang
* @version 创建时间：2016年3月17日 下午3:48:34
* @description 比较类
*/
public class ComparatorFromTo implements Comparator{

@Override
public int compare(Object o1, Object o2) {
FromTo ft1 = (FromTo)o1;
FromTo ft2 = (FromTo)o2;
int flag = 0;
if(ft1.getWeight()>=ft2.getWeight()){
flag=1;
}else{
flag=-1;
}

return flag;
}

@SuppressWarnings("unchecked")
public static void main(String[] args) {
System.out.println("Test !@");
List<FromTo> fts = new ArrayList<FromTo>();

fts.add(new FromTo(3,new TreeNode("A"),new TreeNode("B")));
fts.add(new FromTo(1,new TreeNode("A"),new TreeNode("B")));
fts.add(new FromTo(5,new TreeNode("A"),new TreeNode("B")));
fts.add(new FromTo(2,new TreeNode("A"),new TreeNode("B")));
ComparatorFromTo cft = new ComparatorFromTo();
Collections.sort(fts, cft);
for(int i=0;i<fts.size();i++){
System.out.println(fts.get(i).weight);
}

}

}

package lbz.ch23.mst;

import java.util.ArrayList;
import java.util.List;

/**
* @author LbZhang
* @version 创建时间：2016年3月17日 上午5:14:25
* @description 树结点类
*/
public class TreeNode {
public String vetex;
public List<FromTo> from = new ArrayList<FromTo>();
public List<FromTo> to = new ArrayList<FromTo>();

public TreeNode(String vetex) {
super();
this.vetex = vetex;
}

public TreeNode(String vetex, List<FromTo> from, List<FromTo> to) {
super();
this.vetex = vetex;
this.from = from;
this.to = to;
}

public TreeNode() {
super();
}

public String getVetex() {
return vetex;
}

public void setVetex(String vetex) {
this.vetex = vetex;
}

public List<FromTo> getFrom() {
return from;
}

public void setFrom(List<FromTo> from) {
this.from = from;
}

public List<FromTo> getTo() {
return to;
}

public void setTo(List<FromTo> to) {
this.to = to;
}

}

package lbz.ch23.mst;

import java.util.ArrayList;
import java.util.List;

/**
* @author LbZhang
* @version 创建时间：2016年3月17日 下午2:56:36
* @description 最小生成树结构类
*/
public class MSTree {

public TreeNode root;//树的根节点
public List<TreeNode> tns = new ArrayList<TreeNode>();
public List<FromTo> fts=new ArrayList<FromTo>();
public MSTree() {
super();
}

public MSTree(TreeNode root) {
super();
this.root = root;
this.tns.add(root);
}

public MSTree(TreeNode r, List<TreeNode> tns, List<FromTo> fts) {
super();
this.root=r;
this.tns = tns;
this.fts = fts;
}
public TreeNode getRoot() {
return root;
}
public void setRoot(TreeNode root) {
this.root = root;
}
public List<TreeNode> getTns() {
return tns;
}
public void setTns(List<TreeNode> tns) {
this.tns = tns;
}
public List<FromTo> getFts() {
return fts;
}
public void setFts(List<FromTo> fts) {
this.fts = fts;
}

/**
* 判断两个顶点是否在当前的最小生成树中
* @param from
* @param to
* @return
*/
public boolean containsTwoNodes(TreeNode from, TreeNode to) {
boolean flag = false;
int count = 0;
//      System.out.println(tns.size());
//      for(int i=0;i<tns.size();i++){
//          System.out.print(":"+tns.get(i).getVetex());
//      }
//      System.out.println();
for(int i=0;i<tns.size();i++){
//判定如果在一个最小生成树中有当前的需要比对的节点count+1
if((tns.get(i).getVetex().equals(from.getVetex()))||(tns.get(i).getVetex().equals(to.getVetex()))){
count++;
}

if(count>=2){
flag=true;
break;
}
}
return flag;
}

/**
* 当前树中包含当前结点
* @param from
* @return
*/
public boolean containsNode(TreeNode tn) {
boolean flag = false;
for(int i=0;i<tns.size();i++){
if((tns.get(i).getVetex().equals(tn.getVetex()))){
flag=true;
break;
}
}
return flag;
}

}

4.3 克鲁斯卡尔（Krusckal）算法的实现

package lbz.ch23.mst;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

/**
* @author LbZhang
* @version 创建时间：2016年3月16日 下午9:09:05
* @description   MST Kruskal算法实现类
* 无向连通图——最小生成树算法的设计实现和测试
*
* MinimumSpanningTree
*/
public class KruskalMST {

public static void main(String[] args) {
System.out.println("My Kruskal MST TEST! ");
Graph g = new Graph();
g.printMGraph();
System.out.println("----无向连通图构建完毕----");
//克鲁斯卡尔算法的最小生成树
Set<FromTo> frset = MstKruskal(g);
Iterator<FromTo> it = frset.iterator();
System.out.println("----最小生成树的结果---");
while(it.hasNext()){
FromTo ft = it.next();
System.out.println(ft.getFrom().getVetex()+"->"+ft.getTo().getVetex()+": "+ ft.getWeight());
}

}

/**
* Kruskal 算法的核心内容的实现
* @param g
* @return
*/
private static Set<FromTo> MstKruskal(Graph g) {

Set<FromTo> FRSet = new HashSet<FromTo>();
//最小生成树列表
MSTree mst = new MSTree();
int n=g.count;//结点的个数

List<MSTree> mstList = new ArrayList<MSTree>();
//初始化各个最小生成树
for(int i=0;i<n;i++){
MSTree mt = new MSTree(new TreeNode(g.getVertexstr()[i]));
mstList.add(mt);
}
//根据权重排序
List<FromTo> fts = g.getSortedEdgeFromTo();
for(int i=0;i<fts.size();i++){
System.out.println(fts.get(i).weight+"  "+fts.get(i).getFrom().getVetex()+"->"+fts.get(i).getTo().getVetex());
}

System.out.println("----根据权重排序   一共有:"+fts.size()+"条边----");

for(int i=0;i<fts.size();i++){
FromTo ft = fts.get(i);
if(ft.getWeight()==8){
System.out.println();
}
if(!findInSameTree(ft.from,ft.to,mstList)){
FRSet.add(ft);
unionRelatedTree(ft.from,ft.to,ft,mstList);
}
}
return FRSet;

}

/**
* 将通过边连接起来的两个最小生成树合并
* @param from
* @param to
* @param ft
* @param mstList
*/
private static void unionRelatedTree(TreeNode from, TreeNode to,
FromTo ft, List<MSTree> mstList) {
MSTree mst1 = new MSTree(),mst2=new MSTree();
int memo = 0;
for(int i=0;i<mstList.size();i++){
MSTree mst = mstList.get(i);
if(mst.containsNode(from)){
mst1=mst;
}else if(mst.containsNode(to)){
mst2=mst;
memo=i;
}
}
//将两个链表合并为一个
mst1.getFts().addAll(mst2.getFts());
mst1.getTns().addAll(mst2.getTns());
mstList.remove(memo);
}

/**
* 判断当前的边的两个端点是否位于同一最小生成树中
* @param from
* @param to
* @param mstList
* @return
*/
private static boolean findInSameTree(TreeNode from, TreeNode to, List<MSTree> mstList) {
boolean flag = false;
for(int i=0;i<mstList.size();i++){
MSTree mst = mstList.get(i);
if(mst.containsTwoNodes(from,to)){
flag=true;
break;
}

}
return flag;
}

}

4.4 普利姆（Prim）算法的实现

package lbz.ch23.mst;

import java.util.Iterator;
import java.util.List;
import java.util.Set;

/**
* @author LbZhang
* @version 创建时间：2016年3月17日 下午8:21:45
* @description MST Prim算法实现类
* 无向连通图——最小生成树算法的设计实现和测试
*/
public class PrimMST {

public static void main(String[] args) {
System.out.println("My Prim MST TEST! ");
Graph g = new Graph();
g.printMGraph();
System.out.println("----无向连通图构建完毕----");
MSTree mst = new MSTree();
TreeNode root = new TreeNode("a");
mst=MstPrim(g,root);

System.out.println("输出Prim构造的最小生成树的结果演示");
for(int i=0;i<mst.getFts().size();i++){
System.out.println(mst.getFts().get(i));
}
System.out.println();
}

private static MSTree MstPrim(Graph g, TreeNode root) {
MSTree mst = new MSTree(root);

//获取当前图中的边从小到大的集合
List<FromTo> fts = g.getSortedEdgeFromTo();

while(mst.getTns().size()<=g.getCount()){
FromTo ft = extractMin(fts,mst);//
if(ft==null){//最后一个会传出null的值
break;
}
mst.getTns().add(ft.to);
mst.getFts().add(ft);

}
return mst;
}

private static FromTo extractMin(List<FromTo> fts, MSTree mst) {
FromTo  ft=null;
TreeNode tnv = null;
for(int i=0;i<fts.size();i++){
ft = fts.get(i);
if(mst.containsNode(ft.from)&&!mst.containsNode(ft.to)){
tnv=ft.to;
ft.to=ft.from;
ft.from=tnv;
fts.remove(i);
break;

}else if(!mst.containsNode(ft.from)&&mst.containsNode(ft.to)){
tnv=ft.from;
ft.from=ft.to;
ft.to=tnv;
fts.remove(i);
break;

}else{
ft=null;
}

}

return ft;

}

}