数据结构 JAVA描述（七） 图的遍历+最小生成树

广度优先搜索(Breadth First Search,BFS)+深度优先搜索（Depth First Search,DFS）

为方便起见，将两种遍历写在了一个类中。

TraverseGraph

package Graph;

import Queue.LinkQueue;

/**
 * @description 图的遍历(广度优先搜索 + 深度优先搜索) 
 *  
 * @date  2015年12月30日
 */
public class TraverseGraph {
    // 访问标志数组
    private static boolean[] visited;

    /**
     * @description 广度优先搜索  
     * @date  2015年12月30日
     */
    public static void BFSTraverse(IGraph G) throws Exception{
        visited = new boolean[G.getVexNum()];
        // 初始化标志数组
        for(int v = 0; v < G.getVexNum(); v++)
            visited[v] = false;

        for(int v = 0; v < G.getVexNum(); v++)
            if( !visited[v])
                BFS(G, v);
    }

    private static void BFS(IGraph G, int v) throws Exception{ 
        visited[v] = true;
        System.out.println(G.getVex(v).toString() + " ");
        LinkQueue Q = new LinkQueue(); //辅助队列
        Q.offer(v); //v入队列
        while( !Q.isEmpty()){
            //队头元素出列并赋值给u
            int u = (Integer)Q.poll();
            for(int w = G.firstAdjVex(u); w >= 0; w = G.nextAdjVex(u, w)){
                if( !visited[w]){
                    visited[w] = true;
                    System.out.println(G.getVex(w).toString() + " ");
                    Q.offer(w);
                }
            }
        }
    }

    /**
     * @description 深度优先搜索  
     * @date  2015年12月30日
     */
    public static void DFSTraverse(IGraph G) throws Exception{
        visited = new boolean[G.getVexNum()];
        // 初始化标志数组
        for(int v = 0; v < G.getVexNum(); v++)
            visited[v] = false;

        for(int v = 0; v < G.getVexNum(); v++)
            if( !visited[v])
                DFS(G, v);
    }

    private static void DFS(IGraph G, int v) throws Exception{ 
        visited[v] = true;
        System.out.println(G.getVex(v).toString() + " ");
        for(int w = G.firstAdjVex(v); w >= 0; w = G.nextAdjVex(v, w)){
            if( !visited[w]){ 
                DFS(G, w);
            } 
        }
    }
}

---

最小生成树：

连通图的生成树是图的极小连通子图，它包含图中的全部顶点，但只有构成一棵树的边；生成树也是图的极大无回路子图，它的边集是关联图中的所有顶点而又没有形成回路的边。 一个有n个顶点的连通图的生成树只能有n-1条边。

克鲁斯卡尔算法：

设图 T = (V, E)是图G的最小生成树：

• T的初始状态为T = （V, 空），即开始时，最小生成树T是图G的生成零图。

• 将图G中的边按照权值从小到大的顺序依次选取，若选取的边未使生成树T形成回路，则加入E中；否则舍弃。直至E中包含了n-1条边为止。

该算法的时间复杂度为0（e log₂ e），即取决于图的边数e

普里姆算法：

参数介绍：

• |u，v|表示两个顶点之间的距离

• |u，V|表示顶点u到顶点集合V中所有顶点的距离中的最小值，由于要遍历V中所有顶点，所以时间复杂度是O（|V|）

• |U，V|表示U中所有顶点到V中所有顶点之间距离的最小值，由于要遍历U和V中的所有顶点，所以时间复杂度是O（|UV|）

基本思想：

• 设图 T = (V, E)是图G的最小生成树，从U=｛u0｝，E=空 开始，必存在一条边（u*，v*），使得|u*，v*| = |U，V|，将（u*，v*）加入边集E中，同时将v*加入到点集U中，知道U = V为止。

• 需要一个辅助数组，用于记录U到V-U具有最小代价的边（u*，v*），针对每一个V-U中的顶点v，在辅助数组中存在一个相应分量closedge[i]，包括该边上的权lowcost（即该顶点到U的距离|v，U|）、该边依附在U中的顶点adjvex。
  需要说明的是，表面上计算closedge[i].lowcost = |v，U|的时间复杂度是O（|U|），但实际上U是在原有基础上逐步扩大的，当有一个新元素加入U时，其实只用将closedge[i].lowcost和新加的这个元素比较即可，时间复杂度是O（1）

MiniSpanTree

package Graph;

/**
 * @description 最小生成树的描述 
 * @date 2015年12月30日
 */
public class MiniSpanTree {
    private final static int INFINITY = Integer.MAX_VALUE;

    /**
     * @description 内部类辅助记录从顶点集U到V-U的代价最小的边 
     * @date 2015年12月30日
     */
    private class CloseEdge {
        Object adjVex;
        int lowCost;

        public CloseEdge(Object adjVex, int lowCost) {
            super();
            this.adjVex = adjVex;
            this.lowCost = lowCost;
        }
    }

    /**
     * @description 用普里姆算法从第u个顶点出发构造网G的最小生成树T，返回由生成树边组成的二维数组 
     * @date 2015年12月30日
     */
    private Object[][] PRIM(MGraph G, Object u) throws Exception {
        Object[][] tree = new Object[G.getVexNum() - 1][2];
        int count = 0;
        CloseEdge[] closeEdge = new CloseEdge[G.getVexNum()];
        int k = G.locateVex(u);

        // 初始化辅助数组
        for (int j = 0; j < G.getVexNum(); j++) {
            if (j != k)
                closeEdge[j] = new CloseEdge(u, G.getArcs()[k][j]);
        }
        closeEdge[k] = new CloseEdge(u, 0); // 初始化U={ u }
        // 选择其余G。vexNum - 1 个顶点
        for (int i = 1; i < G.getVexNum(); i++) {
            // 求出下一个要并入U的顶点：第k个顶点
            k = getMinMum(closeEdge);

            tree[count][0] = closeEdge[k].adjVex; // 原U中的顶点
            tree[count][1] = G.getVexs()[k]; // 要加入U中的顶点
            count++;
            closeEdge[k].lowCost = 0; // 第k个顶点并入U后，其辅助数组值置为0

            /*
             * 新顶点并入U后重新选择 因为并入了一个新的顶点到U中，那么对于每个在V-U的顶点到U的最小距离可能就会改变
             * 如原本U中有v0，V-U中有v1
             * ，v2,v3，那么closeEdge[1,2,3]有个值，现在v1并入了U中，V-U中还有v2，v3，
             * 那么closeEdge[1]
             * 置0，closeEdge[2,3]就要考虑v2——v1和v3——v1的距离并和原来的值做个比较，再取其最小的值
             */
            for (int j = 0; j < G.getVexNum(); j++) {
                if (G.getArcs()[k][j] < closeEdge[j].lowCost)
                    closeEdge[j] = new CloseEdge(G.getVex(k), G.getArcs()[k][j]);
            }
        }
        return tree;
    }

    /**
     * @description 在closeEdge中选出lowCost最小且不为0的顶点 
     * @date 2015年12月30日
     */
    private int getMinMum(CloseEdge[] closeEdge) {
        int min = INFINITY;
        int v = -1;
        for (int i = 0; i < closeEdge.length; i++) {
            if (closeEdge[i].lowCost != 0 && closeEdge[i].lowCost < min) {
                min = closeEdge[i].lowCost;
                v = i;
            }
        }
        return v;
    }

    // 测试
    public static void main(String[] args) throws Exception {
        Object[] vexs = { "v0", "v1", "v2", "v3", "v4", "v5" };
        int[][] arcs = { { INFINITY, 7, 1, 5, INFINITY, INFINITY },
                { 7, INFINITY, 6, INFINITY, 3, INFINITY },
                { 1, 6, INFINITY, 7, 6, 4 },
                { 5, INFINITY, 7, INFINITY, INFINITY, 2 },
                { INFINITY, 3, 6, INFINITY, INFINITY, 7 },
                { INFINITY, INFINITY, 4, 2, 7, INFINITY }, };
        MGraph G = new MGraph(GraphKind.UDG, 6, 10, vexs, arcs);
        Object[][] tree = new MiniSpanTree().PRIM(G, "v1");
        for(int i = 0; i < tree.length; i++)
            System.out.println(tree[i][0]+ "-" + tree[i][1]);
    }

}

测试分析图

普里姆算法构造最小生成树过程：

closedege \ i	1	2	3	4	5	U	V-U	k
adjvex/lowcost	v0 / 7	v0 / 1	v0 / 5			{v0}	{v1, v2, v3, v4, v5}	2
adjvex/lowcost	v2 / 6	0	v0 / 5	v2 / 6	v2 / 4	{v0, v2}	{v1, v3, v4, v5}	5
adjvex/lowcost	v2 / 6	0	v5 / 2	v2 / 6	0	{v0, v2, v5}	{v1, v3, v4}	3
adjvex/lowcost	v2 / 6	0	0	v2 / 6	0	{v0, v2, v3, v5}	{v1, v4}	1
adjvex/lowcost	0	0	0	v1 / 3	0	{v0, v1, v2, v3, v5}	{v4}	4
adjvex/lowcost	0	0	0	0	0	{v0, v1, v2, v3, v4, v5}	null