/************************************************************************* * Compilation: javac Digraph.java * Execution: java Digraph filename.txt * Dependencies: Bag.java In.java StdOut.java * Data files: http://algs4.cs.princeton.edu/42directed/tinyDG.txt * * A graph, implemented using an array of lists. * Parallel edges and self-loops are permitted. * * % java Digraph tinyDG.txt * 13 vertices, 22 edges * 0: 5 1 * 1: * 2: 0 3 * 3: 5 2 * 4: 3 2 * 5: 4 * 6: 9 4 8 0 * 7: 6 9 * 8: 6 * 9: 11 10 * 10: 12 * 11: 4 12 * 12: 9 * *************************************************************************/ import java.util.InputMismatchException; import java.util.NoSuchElementException; import edu.princeton.cs.introcs.In; import edu.princeton.cs.introcs.StdOut; /** * The Digraph class represents a directed graph of vertices * named 0 through V - 1. * It supports the following two primary operations: add an edge to the digraph, * iterate over all of the vertices adjacent from a given vertex. * Parallel edges and self-loops are permitted. * * This implementation uses an adjacency-lists representation, which * is a vertex-indexed array of {@link Bag} objects. * All operations take constant time (in the worst case) except * iterating over the vertices adjacent from a given vertex, which takes * time proportional to the number of such vertices. * * For additional documentation, * see <a href="http://algs4.cs.princeton.edu/42directed">Section 4.2</a> of * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne. * * @author Robert Sedgewick * @author Kevin Wayne */ public class Digraph { private final int V; private int E; private Bag<Integer>[] adj; /** * Initializes an empty digraph with V vertices. * @param V the number of vertices * @throws java.lang.IllegalArgumentException if V < 0 */ public Digraph(int V) { if (V < 0) throw new IllegalArgumentException("Number of vertices in a Digraph must be nonnegative"); this.V = V; this.E = 0; adj = (Bag<Integer>[]) new Bag[V]; for (int v = 0; v < V; v++) { adj[v] = new Bag<Integer>(); } } /** * Initializes a digraph 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, with each entry separated by whitespace. * @param in the input stream * @throws java.lang.IndexOutOfBoundsException if the endpoints of any edge are not in prescribed range * @throws java.lang.IllegalArgumentException if the number of vertices or edges is negative */ public Digraph(In in) { try { this.V = in.readInt(); if (V < 0) throw new IllegalArgumentException("Number of vertices in a Digraph must be nonnegative"); adj = (Bag<Integer>[]) new Bag[V]; for (int v = 0; v < V; v++) { adj[v] = new Bag<Integer>(); } int E = in.readInt(); if (E < 0) throw new IllegalArgumentException("Number of edges in a Digraph must be nonnegative"); for (int i = 0; i < E; i++) { int v = in.readInt(); int w = in.readInt(); addEdge(v, w); } } catch (NoSuchElementException e) { throw new InputMismatchException("Invalid input format in Digraph constructor"); } } /** * Initializes a new digraph that is a deep copy of G . * @param G the digraph to copy */ public Digraph(Digraph 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<Integer> reverse = new Stack<Integer>(); for (int w : G.adj[v]) { reverse.push(w); } for (int w : reverse) { adj[v].add(w); } } } /** * Returns the number of vertices in the digraph. * @return the number of vertices in the digraph */ public int V() { return V; } /** * Returns the number of edges in the digraph. * @return the number of edges in the digraph */ public int E() { return E; } /** * Adds the directed edge v->w to the digraph. * @param v the tail vertex * @param w the head vertex * @throws java.lang.IndexOutOfBoundsException unless both 0 <= v < V and 0 <= w < V */ public void addEdge(int v, int w) { if (v < 0 || v >= V) throw new IndexOutOfBoundsException("vertex " + v + " is not between 0 and " + (V-1)); if (w < 0 || w >= V) throw new IndexOutOfBoundsException("vertex " + w + " is not between 0 and " + (V-1)); adj[v].add(w); E++; } /** * Returns the vertices adjacent from vertex v in the digraph. * @return the vertices adjacent from vertex v in the digraph, as an Iterable * @param v the vertex * @throws java.lang.IndexOutOfBoundsException unless 0 <= v < V */ public Iterable<Integer> adj(int v) { if (v < 0 || v >= V) throw new IndexOutOfBoundsException(); return adj[v]; } /** * Returns the reverse of the digraph. * @return the reverse of the digraph */ public Digraph reverse() { Digraph R = new Digraph(V); for (int v = 0; v < V; v++) { for (int w : adj(v)) { R.addEdge(w, v); } } return R; } /** * Returns a string representation of the 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 */ @Override public String toString() { StringBuilder s = new StringBuilder(); String NEWLINE = System.getProperty("line.separator"); s.append(V + " vertices, " + E + " edges " + NEWLINE); for (int v = 0; v < V; v++) { s.append(String.format("%d: ", v)); for (int w : adj[v]) { s.append(String.format("%d ", w)); } s.append(NEWLINE); } return s.toString(); } /** * Unit tests the Digraph data type. */ public static void main(String[] args) { In in = new In(args[0]); Digraph G = new Digraph(in); StdOut.println(G); } }