Below is the syntax highlighted version of DirectedCycle.java
from §4.2 Directed Graphs.

/****************************************************************************** * Compilation: javac DirectedCycle.java * Execution: java DirectedCycle input.txt * Dependencies: Digraph.java Stack.java StdOut.java In.java * Data files: https://algs4.cs.princeton.edu/42digraph/tinyDG.txt * https://algs4.cs.princeton.edu/42digraph/tinyDAG.txt * * Finds a directed cycle in a digraph. * * % java DirectedCycle tinyDG.txt * Directed cycle: 3 5 4 3 * * % java DirectedCycle tinyDAG.txt * No directed cycle * ******************************************************************************/ /** * The {@code DirectedCycle} class represents a data type for * determining whether a digraph has a directed cycle. * The <em>hasCycle</em> operation determines whether the digraph has * a simple directed cycle and, if so, the <em>cycle</em> operation * returns one. * <p> * This implementation uses depth-first search. * The constructor takes Θ(<em>V</em> + <em>E</em>) time in the worst * case, where <em>V</em> is the number of vertices and <em>E</em> is * the number of edges. * Each instance method takes Θ(1) time. * It uses Θ(<em>V</em>) extra space (not including the digraph). * <p> * See {@link Topological} to compute a topological order if the * digraph is acyclic. * <p> * For additional documentation, * see <a href="https://algs4.cs.princeton.edu/42digraph">Section 4.2</a> of * <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne. * * @author Robert Sedgewick * @author Kevin Wayne */ public class DirectedCycle { private boolean[] marked; // marked[v] = has vertex v been marked? private int[] edgeTo; // edgeTo[v] = previous vertex on path to v private boolean[] onStack; // onStack[v] = is vertex on the stack? private Stack<Integer> cycle; // directed cycle (or null if no such cycle) /** * Determines whether the digraph {@code G} has a directed cycle and, if so, * finds such a cycle. * @param G the digraph */ public DirectedCycle(Digraph G) { marked = new boolean[G.V()]; onStack = new boolean[G.V()]; edgeTo = new int[G.V()]; for (int v = 0; v < G.V(); v++) if (!marked[v] && cycle == null) dfs(G, v); } // run DFS and find a directed cycle (if one exists) private void dfs(Digraph G, int v) { onStack[v] = true; marked[v] = true; for (int w : G.adj(v)) { // short circuit if directed cycle found if (cycle != null) return; // found new vertex, so recur else if (!marked[w]) { edgeTo[w] = v; dfs(G, w); } // trace back directed cycle else if (onStack[w]) { cycle = new Stack<Integer>(); for (int x = v; x != w; x = edgeTo[x]) { cycle.push(x); } cycle.push(w); cycle.push(v); assert check(); } } onStack[v] = false; } /** * Does the digraph have a directed cycle? * @return {@code true} if the digraph has a directed cycle, {@code false} otherwise */ public boolean hasCycle() { return cycle != null; } /** * Returns a directed cycle if the digraph has a directed cycle, and {@code null} otherwise. * @return a directed cycle (as an iterable) if the digraph has a directed cycle, * and {@code null} otherwise */ public Iterable<Integer> cycle() { return cycle; } // certify that digraph has a directed cycle if it reports one private boolean check() { if (hasCycle()) { // verify cycle int first = -1, last = -1; for (int v : cycle()) { if (first == -1) first = v; last = v; } if (first != last) { System.err.printf("cycle begins with %d and ends with %d\n", first, last); return false; } } return true; } /** * Unit tests the {@code DirectedCycle} data type. * * @param args the command-line arguments */ public static void main(String[] args) { In in = new In(args[0]); Digraph G = new Digraph(in); DirectedCycle finder = new DirectedCycle(G); if (finder.hasCycle()) { StdOut.print("Directed cycle: "); for (int v : finder.cycle()) { StdOut.print(v + " "); } StdOut.println(); } else { StdOut.println("No directed cycle"); } StdOut.println(); } }

Last updated: Sat Oct 24 20:39:49 EDT 2020.