算法4第4章加权无向图/Prim/Kruskal算法计算最小生成树讲解

最新推荐文章于 2022-04-04 18:05:31 发布

csprimer

最新推荐文章于 2022-04-04 18:05:31 发布

阅读量897

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/cyj88jyc/article/details/94144791

版权

本文介绍了加权无向图的概念，它在多种应用场景中有广泛用途，如航班图、电路图等。提供了一个EdgeWeightedGraph类的Java实现，包括构造函数、添加边、获取邻接表等方法。此外，还提到了最小生成树的计算，如Prim和Kruskal算法，这些算法用于找到连接所有顶点的最低成本路径。

摘要由CSDN通过智能技术生成

加权无向图
加权图是为每条边关联一个权值的图模型，这种图可以自然的表示很多应用，在一副航班图中边表示航线，权值代表距离或价格，电路图中边表示电线，权值代表电线长度
边的权重不一定是距离,也可能是时间，费用，也可能是0或负数
加权无向图代码实现如下,只用把Graph实现里的Bag<Integer>换成Bag<Edge>,用Edge表示有权重的边
public class EdgeWeightedGraph {
private static final String NEWLINE = System.getProperty("line.separator");

private final int V;
 private int E;
 private Bag<Edge>[] adj;

 /**
 * Initializes an empty edge-weighted graph with {@code V} vertices and 0 edges.
 *
 * @param V the number of vertices
 * @throws IllegalArgumentException if {@code V < 0}
 */
 public EdgeWeightedGraph(int V) {
 if (V < 0) throw new IllegalArgumentException("Number of vertices must be nonnegative");
 this.V = V;
 this.E = 0;
 adj = (Bag<Edge>[]) new Bag[V];
 for (int v = 0; v < V; v++) {
 adj[v] = new Bag<Edge>();
 }
 }

/**
 * Initializes a random edge-weighted graph with {@code V} vertices and E edges.
 *
 * @param V the number of vertices
 * @param E the number of edges
 * @throws IllegalArgumentException if {@code V < 0}
 * @throws IllegalArgumentException if {@code E < 0}
 */
 public EdgeWeightedGraph(int V, int E) {
 this(V);
 if (E < 0) throw new IllegalArgumentException("Number of edges must be nonnegative");
 for (int i = 0; i < E; i++) {
 int v = StdRandom.uniform(V);
 int w = StdRandom.uniform(V);
 double weight = Math.round(100 * StdRandom.uniform()) / 100.0;
 Edge e = new Edge(v, w, weight);
 addEdge(e);
 }
 }

/**
 * Initializes an edge-weighted graph from an input stream.
 * The format is the number of vertices V,
 * followed by the number of edges E,
 * followed by E pairs of vertices and edge weights,
 * with each entry separated by whitespace.
 *
 * @param in the input stream
 * @throws IllegalArgumentException if the endpoints of any edge are not in prescribed range
 * @throws IllegalArgumentException if the number of vertices or edges is negative
 */
 public EdgeWeightedGraph(In in) {
 this(in.readInt());
 int E = in.readInt();
 if (E < 0) throw new IllegalArgumentException("Number of edges must be nonnegative");
 for (int i = 0; i < E; i++) {
 int v = in.readInt();
 int w = in.readInt();
 validateVertex(v);
 validateVertex(w);
 double weight = in.readDouble();
 Edge e = new Edge(v, w, weight);
 addEdge(e);
 }
 }

/**
 * Initializes a new edge-weighted graph that is a deep copy of {@code G}.
 *
 * @param G the edge-weighted graph to copy
 */
 public EdgeWeightedGraph(EdgeWeightedGraph G) {
 this(G.V());
 this.E = G.E();
 for (int v = 0; v < G.V(); v++) {
 // reverse so that adjacency list is in same order as original
 Stack<Edge> reverse = new Stack<Edge>();
 for (Edge e : G.adj[v]) {
 reverse.push(e);
 }
 for (Edge e : reverse) {
 adj[v].add(e);
 }
 }
 }

    /**
     * Returns the number of vertices in this edge-weighted graph.
     *
     * @return the number of vertices in this edge-weighted graph
     */
    public int V() {
        return V;
    }

    /**
     * Returns the number of edges in this edge-weighted graph.
     *
     * @return the number of edges in this edge-weighted graph
     */
    public int E() {
        return E;
    }

// throw an IllegalArgumentException unless {@code 0 <= v < V}
 private void validateVertex(int v) {
 if (v < 0 || v >= V)
 throw new IllegalArgumentException("vertex " + v + " is not between 0 and " + (V-1));
 }

    /**
     * Adds the undirected edge {@code e} to this edge-weighted graph.
     *
     * @param e the edge
     * @throws IllegalArgumentException unless both endpoints are between {@code 0} and {@code V-1}
     */
    public void addEdge(Edge e) {
        int v = e.either();
        int w = e.other(v);
        validateVertex(v);
        validateVertex(w);
        adj[v].add(e);
        adj[w].add(e);
        E++;
    }

/**
 * Returns the edges incident on vertex {@code v}.
 *
 * @param v the vertex
 * @return the edges incident on vertex {@code v} as an Iterable
 * @throws IllegalArgumentException unless {@code 0 <= v < V}
 */
 public Iterable<Edge> adj(int v) {
 validateVertex(v);
 return adj[v];
 }

/**
 * Returns the degree of vertex {@code v}.
 *
 * @param v the vertex
 * @return the degree of vertex {@code v}
 * @throws IllegalArgumentException unless {@code 0 <= v < V}
 */
 public int degree(int v) {
 validateVertex(v);
 return adj[v].size();
 }

/**
 * Returns all edges in this edge-weighted graph.
 * To iterate over the edges in this edge-weighted graph, use foreach notation:
 * {@code for (Edge e : G.edges())}.
 *
 * @return all edges in this edge-weighted graph, as an iterable
 */
 public Iterable<Edge> edges() {
 Bag<Edge> list = new Bag<Edge>();
 for (int v = 0; v < V; v++) {
 int selfLoops = 0;
 for (Edge e : adj(v)) {
 if (e.other(v) > v) {
 list.add(e);
 }
 // add only one copy of each self loop (self loops will be consecutive)
 else if (e.other(v) == v) {
 if (selfLoops % 2 == 0) list.add(e);
 selfLoops++;
 }
 }
 }
 return list;
 }

/**
 * Returns a string representation of the edge-weighted graph.
 * This method takes time proportional to E + V.
 *
 * @return the number of vertices V, followed by the number of edges E,
 * followed by the V adjacency lists of edges
 */
 public String toString() {
 StringBuilder s = new StringBuilder();
 s.append(V + " " + E + NEWLINE);
 for (int v = 0; v < V; v++) {
 s.append(v + ": ");
 for (Edge e : adj[v]) {
 s.append(e + " ");
 }
 s.append(NEWLINE);
 }
 return s.toString();
 }

    /**
     * Unit tests the {@code EdgeWeightedGraph} data type.
     *
     * @param args the command-line arguments
     */
    public static void main(String[] args) {
        In in = new In(args[0]);
        EdgeWeightedGraph G = new EdgeWeightedGraph(in);
        StdOut.println(G);
    }

}

/******************************************************************************
* Compilation: javac Edge.java
* Execution: java Edge
* Dependencies: StdOut.java
*
* Immutable weighted edge.
*
******************