最小生成树算法-Prim算法

MST（Minimum Spanning Tree，最小生成树）问题有两种通用的解法，Prim算法就是其中之一，它是从点的方面考虑构建一颗MST，大致思想是：设图G顶点集合为U，首先任意选择图G中的一点作为起始点a，将该点加入集合V，再从集合U-V中找到另一点b使得点b到V中任意一点的权值最小，此时将b点也加入集合V；以此类推，现在的集合V={a，b}，再从集合U-V中找到另一点c使得点c到V中任意一点的权值最小，此时将c点加入集合V，直至所有顶点全部被加入V，此时就构建出了一颗MST。因为有N个顶点，所以该MST就有N-1条边，每一次向集合V中加入一个点，就意味着找到一条MST的边。

package com.gloomy.graph;

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

/**
 * 最小生成树算法
 * 与Dijkstra算法思路几乎完全一致
 * 
 * @author 过路的守望
 *
 */
public class PrimAlgorithm {

    public static void main(String[] args) {

        Vertex A = new Vertex("A");
        Vertex B = new Vertex("B");
        Vertex C = new Vertex("C");
        Vertex D = new Vertex("D");
        Vertex E = new Vertex("E");
        Vertex F = new Vertex("F");
        Vertex G = new Vertex("G");
        A.getAdjacentList().add(B);
        A.getAdjacentList().add(D);
        A.getAdjacentList().add(C);
        A.getAdjacentEdgesMap().put(B, 2);
        A.getAdjacentEdgesMap().put(C, 4);
        A.getAdjacentEdgesMap().put(D, 1);
        B.getAdjacentList().add(E);
        B.getAdjacentList().add(D);
        B.getAdjacentList().add(A);
        B.getAdjacentEdgesMap().put(A, 2);
        B.getAdjacentEdgesMap().put(D, 3);
        B.getAdjacentEdgesMap().put(E, 10);
        C.getAdjacentList().add(A);
        C.getAdjacentList().add(D);
        C.getAdjacentList().add(F);
        C.getAdjacentEdgesMap().put(A, 4);
        C.getAdjacentEdgesMap().put(D, 2);
        C.getAdjacentEdgesMap().put(F, 5);
        D.getAdjacentList().add(A);
        D.getAdjacentList().add(B);
        D.getAdjacentList().add(C);
        D.getAdjacentList().add(E);
        D.getAdjacentList().add(F);
        D.getAdjacentList().add(G);
        D.getAdjacentEdgesMap().put(A, 1);
        D.getAdjacentEdgesMap().put(B, 3);
        D.getAdjacentEdgesMap().put(C, 2);
        D.getAdjacentEdgesMap().put(E, 7);
        D.getAdjacentEdgesMap().put(F, 8);
        D.getAdjacentEdgesMap().put(G, 4);
        E.getAdjacentList().add(B);
        E.getAdjacentList().add(D);
        E.getAdjacentList().add(G);
        E.getAdjacentEdgesMap().put(B, 10);
        E.getAdjacentEdgesMap().put(D, 7);
        E.getAdjacentEdgesMap().put(G, 6);
        F.getAdjacentList().add(C);
        F.getAdjacentList().add(D);
        F.getAdjacentList().add(G);
        F.getAdjacentEdgesMap().put(C, 5);
        F.getAdjacentEdgesMap().put(D, 8);
        F.getAdjacentEdgesMap().put(G, 1);
        G.getAdjacentList().add(F);
        G.getAdjacentList().add(D);
        G.getAdjacentList().add(E);
        G.getAdjacentEdgesMap().put(F, 1);
        G.getAdjacentEdgesMap().put(E, 6);
        G.getAdjacentEdgesMap().put(D, 4);
        List<Vertex> vertexs = new ArrayList<Vertex>();
        vertexs.add(A);
        vertexs.add(B);
        vertexs.add(C);
        vertexs.add(D);
        vertexs.add(E);
        vertexs.add(F);
        vertexs.add(G);
        PrimAlgorithm prim = new PrimAlgorithm();
        prim.primTree(A, vertexs);
    }

    /**
     * 
     * @param vertex
     *            指定的根
     * @param vertexs
     *            顶点的集合
     */
    public void primTree(Vertex vertex, List<Vertex> vertexs) {
        Vertex curVertex = vertex;
        vertex.setDist(0);
        while (true) {
            /*
             * 已经处理完所有顶点
             */
            if (curVertex == null) {
                break;
            }
            curVertex.setVisited(true);
            for (Vertex adjaVertex : curVertex.getAdjacentList()) {
                /*
                 * 若adjacent顶点未处理
                 * 且d[w]=min(d[w],C(w,v))变小
                 * 更新此顶点
                 */
                if (!adjaVertex.isVisited()) {
                    if (adjaVertex.getDist() > curVertex.getAdjacentEdgesMap()
                            .get(adjaVertex)) {
                        adjaVertex.setDist(curVertex.getAdjacentEdgesMap().get(
                                adjaVertex));
                        adjaVertex.setPreVertex(curVertex);
                    }
                }

            }
            /*
             * 从未访问顶点中寻找下一个顶点
             */
            curVertex = getShortestVertex(vertexs);

        }
        int length = 0;
        for (Vertex vertex2 : vertexs) {
            length += vertex2.getDist();
        }
        System.out.println("权值和："+length);
    }

    /**
     * 从未访问顶点中寻找最短边
     * 可用二叉堆优化
     * @param vertexs
     * @return
     */
    public Vertex getShortestVertex(List<Vertex> vertexs) {
        int min = Integer.MAX_VALUE;
        /*
         * 最短边
         */
        Vertex minVertex = null;
        for (Vertex vertex : vertexs) {
            if (!vertex.isVisited()) {
                if (vertex.getDist() < min) {
                    min = vertex.getDist();
                    minVertex = vertex;
                }
            }
        }
        return minVertex;
    }

}

权值和：16