图-最小生成树算法之Kruskal及其Java实现

1.Kruskal算法

Kruskal算法基于贪心，因此它追求的是近似最优解，也就是说由Kruskal得出的生成树并不一定是最优解。

Kruskal算法求最小生成树的关键在于，每次选取图中权值最小（及贪心），并不会构成环的边，直到所有点都被囊括。一般，边的个数=点的个数-1。

如下无向图：

要找到最小生成树，克鲁斯卡尔算法的步骤如下：

 

 

2.Java实现

针对上述《算法导论》中的例子，有Java代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

//图类 无向图
class G{
    ArrayList<V> vs=new ArrayList<V>();
    ArrayList<E> es=new ArrayList<E>();
    
    public void addV(V v) {
        vs.add(v);
    }
    
    public void add(E e) {
        es.add(e);
    }
}

//点
class V{
    String name;
    boolean isvisited=false;
    
    public V(String name) {
        this.name=name;
    }

    @Override
    public String toString() {
        return name;
    }
}

//边
class E{
    V v1;   //点
    V v2;   //点
    int Weight;   //权重
    boolean isvisited=false;
    
    public E(V v1,V v2,int Weight) {
        this.v1=v1;
        this.v2=v2;
        this.Weight=Weight;
    }

    @Override
    public String toString() {
        return "(" + v1 + ", " + v2 + ":" + Weight + ")";
    }
}

public class MinTree {
    //克鲁斯卡尔
    static void kruskal(G graph) {
        ArrayList<E> edges=graph.es;  //存储图的边集合
        ArrayList<E> forest=new ArrayList<E>();  //存放符合结果的边
        
        for(E e:edges) {   //遍历边集合，在初始化图的时候，边已按照权值排序
            ArrayList<E> testForest=refreshForest(forest);
            getEnd(testForest,e.v1,e.v2);
            if(endV) {  //判断是否形成回路
                System.out.print(e);    //输出符合条件（不形成回路，权值最小）的边
                forest.add(e);
            }
        }
    }
    
    //将图的边集合按权值排序
    static ArrayList<E> sortEdgeByWeight(ArrayList<E> es){
        for(int i=0;i<es.size();i++) {
            for(int j=0;j<es.size();j++) {
                if(es.get(i).Weight<es.get(j).Weight) {
                    Collections.swap(es, i, j);
                }
            }
        }
        return es;
    }
    
    static boolean endV=true;
    //判断新的边是否会和已有森林形成环：即得到目标点的末节点，由此判断两者是否相同，若相同则有环
    static void getEnd(ArrayList<E> testForest,V start,V end) {
        for(E e:testForest) {
            if(e.isvisited==false) {
                if(e.v1.equals(start)) {
                    e.isvisited=true;
                    if(e.v2.equals(end)) {
                        endV=false;
                    }else {
                        getEnd(testForest,e.v2,end);
                    }
                }else if (e.v2.equals(start)) {
                    e.isvisited=true;
                    if(e.v1.equals(end)) {
                        endV=false;
                    }else {
                        getEnd(testForest,e.v1,end);
                    }
                }
            }
        }
    }
    
    //刷新森林：将森林中所有边标为未被查看，将endV标志也初始化一下
    static ArrayList<E> refreshForest(ArrayList<E> forest) {
        endV=true;
        for(E e:forest) {
            e.isvisited=false;
        }
        return forest;
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建点
        V a=new V("a");
        V b=new V("b");
        V c=new V("c");
        V d=new V("d");
        V e=new V("e");
        V f=new V("f");
        V g=new V("g");
        V h=new V("h");
        V i=new V("i");
        //创建点
        
        //创建边
        E e0=new E(a,b,4);
        E e1=new E(a,h,8);
        E e2=new E(b,h,11);
        E e3=new E(b,c,8);
        E e4=new E(h,i,7);
        E e5=new E(h,g,1);
        E e6=new E(i,c,2);
        E e7=new E(i,g,6);
        E e8=new E(c,d,7);
        E e9=new E(c,f,4);
        E e10=new E(g,f,2);
        E e11=new E(d,f,14);
        E e12=new E(d,e,9);
        E e13=new E(f,e,10);
        //创建边
        
        //创建图
        G graph=new G();
        graph.addV(a);
        graph.addV(b);
        graph.addV(c);
        graph.addV(d);
        graph.addV(e);
        graph.addV(f);
        graph.addV(g);
        graph.addV(h);
        graph.addV(i);
        ArrayList<E> es=new ArrayList<E>();
        es.add(e0);
        es.add(e1);
        es.add(e2);
        es.add(e3);
        es.add(e4);
        es.add(e5);
        es.add(e6);
        es.add(e7);
        es.add(e8);
        es.add(e9);
        es.add(e10);
        es.add(e11);
        es.add(e12);
        es.add(e13);
        graph.es=sortEdgeByWeight(es);
        //创建图
        
        //输出图
        ArrayList<V> vertexs=graph.vs;
        ArrayList<E> edges=graph.es;
        Iterator iVertex=vertexs.iterator();
        Iterator iEdge=edges.iterator();
        System.out.println("点集合：");
        while(iVertex.hasNext()) {
            System.out.print(iVertex.next());
        }
        System.out.println();
        System.out.println("边集合：");
        while(iEdge.hasNext()) {
            System.out.print(iEdge.next());
        }
        //输出图
        
        //最小生成树
        //克鲁斯卡尔
        System.out.println("");
        System.out.println("克鲁斯卡尔：");
        kruskal(graph);
        //最小生成树

    }

}

输出：