圖-最小生成樹算法之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);
        //最小生成樹

    }

}

輸出：