带权图的最小生成树问题

假设共有六个定点，分别为命名为０-５，如下图所示：

根据图构建出邻接矩阵adjMat[][]如下（其中权值为-1表示该两点之间没有路径）：

adjMat[][] 0 1 2 3 4 5 0 -1 6 -1 4 -1 -1 1 6 -1 10 7 7 -1 2 -1 10 -1 8 5 6 3 -1 7 8 -1 12 -1 4 -1 -1 12 -1 -1 7 5 -1 -1 -1 -1 7 -1

分析

优先级队列以数组的方式来实现，并且数组中，权值越大的值数组下标越小。
首先从任意节点开始，这里从０节点开始，通过搜索邻接矩阵找到0节点到所有相连接点的边：
１、以当前节点号为行遍历该行所有的列，其中列不能等于行号（行号等于列号时代表自身与自身相连）。
２、当该行上某一列的值部不为-1时，代表该点与行值点相连，该值为连线的权值。该案例中邻接矩阵adjMat[0][1]和adjMat[0][3]两个元素不为-1。
３、将该边放在优先级队列中。本案例中队列中有边0-1(6)、0-3(4)。
４、得到优先级队列中的队首元素（即队列中权值最小的元素）并将该边从队列中删除，这里为边0-3。
５、以该边的终点作为新的顶点，这里即边0-3中3为新的顶点。重复以上五个步骤。
注意并不是要把搜索的到邻接矩阵中所有非-1边都放入队列中的，必须符合以下条件的才能进入队列：
１、边的的起点和终点不能是同一个。
２、边的终点已经在树中。
３、边的权值不为-1。

代码的实现

程序主要有四个类构成

１、顶点类Vertex
顶点类具有两个属性，顶点的名字和改点是否已经在树中

class Vertex {    public char label;    public boolean isInTree;    public Vertex(char label) {        this.label = label;        isInTree = false;    }}

２、边类Edge
边类包含三个属性，分别时起点srcVert、终点destVert、边的权重这里用distance表示。

class Edge {    //    starting edge    public int srcVert;    //    ending edge    public int destVert;    public int distance;    public Edge(int srcVert, int destVert, int distance) {        this.srcVert = srcVert;        this.destVert = destVert;        this.distance = distance;    }}

３、优先级队列类PriorityQ
优先级队列采用数组queArray实现，实现方法比较简单但不严谨，比如队列只能朝一个方向插入，抽取。因此打算专门写一篇文章讨论队列的实现，这里不做重点讨论。并且优先级队列还可以用堆来实现。
队列中用size来标示队列中的元素个数。
队列中包含insert()、removeMin()、peekMin()、peekN()、find()等方法。
insert()用来队列的插入，将权值小的放在队列的首部，即放在数组下标较大的位置；
removeMin()是移除队队首元素即分析部分中所描述的步骤4；
peekMin()用来查看队首元素；
peekN()用来查看队列中下表为n的元素;
find()用来查找边的终点是否已经包含在队列中。

class PriorityQ {    private final int SIZE = 20;    private Edge[] queArray;    private int size;    public PriorityQ() {        queArray = new Edge[SIZE];        size = 0;    }    public void insert(Edge item) {        int j;        for (j = 0; j < size; j++) {            if (item.distance >= queArray[j].distance) {                break;            }        }        for (int k = size - 1; k >= j; k--) {            queArray[k+1] = queArray[k];        }        queArray[j] = item;        size++;    }    public Edge removeMin() {        return queArray[--size];    }    public void removeN(int n) {        for (int j = n; j < size - 1; j++) {            queArray[j] = queArray[j + 1];        }        size--;    }    public Edge peekMin() {        return queArray[size--];    }    public int size() {        return size;    }    public boolean isEmpty() {        return (size == 0);    }    public Edge peekN(int n) {        return queArray[n];    }    public int find(int findDex) {        for (int j = 0; j < size; j++) {            if (queArray[j].destVert == findDex) {                return j;            }        }        return -1;    }}

４、图类Graph
图类中包含邻接矩阵adjMat[][]、顶点数组列表vertexList[]、优先级队列thePQ等，包含mstw()和putInPQ()两个重要的方法
mstw()是实现最小生成树的核心代码：
从顶点0开始搜索，当树中的元素个数和顶点的个数相同时while循环结束算法退出。
按照分析中所述的方法，一次遍历每一行的每一个值，当遇到符合条件的边时调用putInPQ()方法进行队列插入；
然后从优先级队列中取出队收的边元素，以改变元素的终点作为新的顶点，进行下一步。
putInPQ()时队列执行插入的方法
要插入的边的终点不在队列中是，表示这是一个新的节点，因此直接将该边插入队列中，当该边的终点已经在队列中时，查找出队列中到达该终点的旧边，查看旧边的权值，如果旧边的权值比新边的权值大那么将旧的边删除，将新的边插入，否者新的边不再插入队列。解释为如果又发现了一条到达节点的新路径，如果新路径权值比原来的路径权值要小那么就采用新的路径，否者沿用旧的路径。

class Graph {    private final int MAX_VERTS = 8;    private final int INIFITY = -1;    private Vertex[] vertexList;    private int adjMat[][];    private int nVerts;    private int currentVert;    private PriorityQ thePQ;    private int nTree;    public Graph() {        vertexList = new Vertex[MAX_VERTS];        adjMat = new int[MAX_VERTS][MAX_VERTS];        nVerts = 0;        for (int i = 0; i < MAX_VERTS; i++) {            for (int j = 0; j < MAX_VERTS; j++) {                adjMat[i][j] = INIFITY;            }        }        thePQ = new PriorityQ();    }    public void addVertex(char lab) {        vertexList[nVerts++] = new Vertex(lab);    }    public void addEdge(int start, int end, int weight) {        adjMat[start][end] = weight;        adjMat[end][start] = weight;    }    public void displayVertex(int v) {        System.out.println(vertexList[v].label);    }    public void mstw() {        currentVert = 0;        while (nTree < nVerts - 1) {            vertexList[currentVert].isInTree = true;            nTree++;            for (int j = 0; j < nVerts; j++) {                if (j == currentVert) {                    continue;                }                if (vertexList[j].isInTree) {                    continue;                }                int distance = adjMat[currentVert][j];                if (distance == INIFITY) {                    continue;                }                putInPQ(j, distance);            }            if (thePQ.size() == 0) {                System.out.println("GRAPH NOT CONNECTED");                return;            }            Edge theEdge = thePQ.removeMin();            int sourceVert = theEdge.srcVert;            currentVert = theEdge.destVert;            System.out.print(vertexList[sourceVert].label);            System.out.print(vertexList[currentVert].label);            System.out.print(" ");        }        for (int i = 0; i < nVerts; i++) {            vertexList[i].isInTree = false;        }    }    public void putInPQ(int newVert, int newDist) {        int queueIndex = thePQ.find(newVert);        if (queueIndex != -1) {            Edge tempEdge = thePQ.peekN(queueIndex);            int oldDist = tempEdge.distance;            if (oldDist > newDist) {                thePQ.removeN(queueIndex);                Edge theEdge = new Edge(currentVert, newVert, newDist);                thePQ.insert(theEdge);            }        } else {            Edge theEdge = new Edge(currentVert, newVert, newDist);            thePQ.insert(theEdge);        }    }}

程序测试：

public class MSTWApp {    public static void main(String[] args) {        Graph theGraph = new Graph();        theGraph.addVertex('A');        theGraph.addVertex('B');        theGraph.addVertex('C');        theGraph.addVertex('D');        theGraph.addVertex('E');        theGraph.addVertex('F');        theGraph.addEdge(0,1,6);        theGraph.addEdge(0,3,4);        theGraph.addEdge(1,2,10);        theGraph.addEdge(1,3,7);        theGraph.addEdge(1,4,7);        theGraph.addEdge(2,3,8);        theGraph.addEdge(2,4,5);        theGraph.addEdge(2,5,6);        theGraph.addEdge(3,4,12);        theGraph.addEdge(4,5,7);        System.out.println("Minimum spanning tree : ");        theGraph.mstw();        System.out.println();    }}

结果为：

Minimum spanning tree : AD AB BE EC CF