有向图最小生成树算法

边数据结构

class Edge {
    private int srcVert;
    private int destVert;
    private int distance;
}

改造优先级队列

public class PriorityQueue {
    private final int SIZE = 20;
    private Edge[] queArray;
    private int size;

    public PriorityQueue() {
        queArray = new Edge[SIZE];
        size = 0;
    }

    public void insert(Edge item) {
        int j = 0;
        for (j = 0; j < size; j++)
            if (item.getDistance() >= queArray[j].getDistance()) break;
        if (size - j >= 0) System.arraycopy(queArray, j, queArray, j + 1, size - j);
        queArray[j] = item;
        size++;
    }

    public Edge removeMin() {
        return queArray[--size];
    }

    public void removeN(int n) {
        if (size - 1 - n >= 0) System.arraycopy(queArray, n + 1, queArray, n, size - 1 - n);
        size--;
    }

    public Edge peekMin() {
        return queArray[size - 1];
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public Edge peekN(int n) {
        return queArray[n];
    }

    public int find(int idx) {
        for (int i = 0; i < size; i++)
            if (queArray[i].getDestVert() == idx) return i;
        return -1;
    }

}

最小生成树

public class MinimumSpanningTree {
    private final int MAX_VERTS = 20;
    private final int INFINITY = 100000;
    private Vertex[] vertexList;
    private int[][] adjMat;
    private int nVerts;

    public MinimumSpanningTree() {
        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] = INFINITY;
    }

    public void addVertex(char label) {
        vertexList[nVerts++] = new Vertex(label);
    }

    public void addEdge(int start, int end, int weight) {
        adjMat[start][end] = weight;
        adjMat[end][start] = weight;
    }

    int currentVert;

    public void mstw() {
        int nTree = 0;
        currentVert = 0;
        PriorityQueue queue = new PriorityQueue();
        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 == INFINITY) continue;
                putIntoPQ(j, distance, queue);
            }
            if (queue.isEmpty()) {
                System.out.println("Graph not connected");
                return;
            }
            Edge minEdge = queue.removeMin();
            int srcVert = minEdge.getSrcVert();
            currentVert = minEdge.getDestVert();

            System.out.print(vertexList[srcVert].label);
            System.out.print(vertexList[currentVert].label);
            System.out.print("\t");
        }
        for (int i = 0; i < nVerts; i++) {
            vertexList[i].isInTree = false;
        }
    }

    private void putIntoPQ(int srcVert, int distance, PriorityQueue queue) {
        int idx = queue.find(srcVert);
        if (idx != -1) {
            Edge edge = queue.peekN(idx);
            int oldDistance = edge.getDistance();
            if (oldDistance > distance) {
                queue.removeN(idx);
                queue.insert(new Edge(currentVert, srcVert, distance));
            }
        } else queue.insert(new Edge(currentVert, srcVert, distance));

    }

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