在正式编写最小生成树的算法之前，还需要做一些准备工作。具体的工作就是建立一些基础对象。

边

首先需要建立边的对象。现在的边要增加权重信息，一条边需要记录两个端点以及这条边的权重，因此边类的轮廓如下：

public class Edge implements Comparable<Edge> {
    public Edge(int v, int w, double weight) {
    }

    // 返回任意一个端点
    public int either() {
    }

    // 返回另外一个端点
    public int other(int v) {
    }

    // 和另外一条边比较权重
    @Override
    public int compareTo(Edge that) {
    }

    // 返回这条边的权重
    public double weight() {
    }

    @Override
    String toString();
}

接口知道以后，实现方面就非常方便了。

public class Edge implements Comparable<Edge> {
    private int v;
    private int w;
    private double weight;

    public Edge(int v, int w, double weight) {
        this.v = v;
        this.w = w;
        this.weight = weight;
    }

    // 返回任意一个端点
    public int either() {
        return v;
    }

    // 返回另外一个端点
    public int other(int v) {
        if (v == this.v) return w;
        else return this.v;
    }

    // 和另外一条边比较权重
    @Override
    public int compareTo(Edge that) {
        if (this.weight < that.weight) return -1;
        if (this.weight > that.weight) return 1;
        return 0;
    }

    // 返回这条边的权重
    public double weight() {
        return this.weight;
    }

    @Override
    public String toString() {
        return String.format("%s-%s %s", v, w, weight);
    }
}

权重图

下面为权重图建立一个类。它的接口是这样的：

public class EdgeWeightedGraph {
    public EdgeWeightedGraph(int V) {
    }

    // 在图中增加一条边
    public void addEdge(Edge e) {
    }

    // 获取与指定顶点相邻的边
    public Iterable<Edge> adj(int v) {
    }

    // 获取图中所有的边
    public Iterable<Edge> edges() {
    }

    // 获取该图中的顶点数量
    public int V() {
    }

    // 获取该图中的边数
    public int E() {
    }

    // 将图转换成字符串用于显示
    @Override
    public String toString() {
    }
}

这样设计接口的好处就是能够让图支持自连接以及并行连接。权重图的全部代码如下：

import java.util.LinkedList;
import java.util.List;

public class EdgeWeightedGraph {
    private int V;
    private List<Edge>[] adj;
    private List<Edge> allEdges;

    public EdgeWeightedGraph(int V) {
        this.V = V;
        allEdges = new LinkedList<Edge>();
        adj = new LinkedList[V];
        for (int i = 0; i < V; i++) {
            adj[i] = new LinkedList<Edge>();
        }
    }

    // 在图中增加一条边
    public void addEdge(Edge e) {
        int v = e.either();
        int w = e.other(v);
        adj[v].add(e);
        adj[w].add(e);
        allEdges.add(e);
    }

    // 获取与指定顶点相邻的边
    public Iterable<Edge> adj(int v) {
        return adj[v];
    }

    // 获取图中所有的边
    public Iterable<Edge> edges() {
        return allEdges;
    }

    // 获取该图中的顶点数量
    public int V() {
    }

    // 获取该图中的边数
    public int E() {
        return allEdges.size();
    }

    // 将图转换成字符串用于显示
    @Override
    public String toString() {
        String result = "";
        for(Edge e : edges()) {
            result += e.toString();
            result += "\n";
        }
        return result;
    }
}

最小生成树

最小生成树应该从一个权重图创建，而且它的边是权重图的子集，因此MST的接口应该是这样的：

public class MST {
    public MST(EdgeWeightedGraph G) {
    }

    // 返回最小生成树中所有的边
    public Iterable<Edge> edges() {
    }

    // 返回最小生成树中所有边的权重之和
    public double weight() {
    }
}

算法8-3：权重图接口