public boolean isPath(Graph graph, Node start, Node target) { for (Node node : graph.getNode()) { if (node != null) { node.state = State.Unvisited; } } dfs(start); return target.state == State.Visited; }
public void DFS(Node<T> n, Set<Node<T>> visited, ArrayList<T> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Node<T> target : n.edges) { DFS(target, visited, sorted); } } sorted.add(n.payload); } }
public void sortGrammarFiles() throws IOException { Graph<String> g = new Graph<String>(); List<String> missingFiles = new ArrayList<String>(); for (String gfile : grammarFileNames) { String grammarName = grammar.getGrammarName(); if ( vocabName!=null ) g.addEdge(gfile, vocabName+CodeGenerator.VOCAB_FILE_EXTENSION); g.addEdge(grammarName+CodeGenerator.VOCAB_FILE_EXTENSION, gfile); List<String> sorted = g.sort();
public void sortGrammarFiles() throws IOException { Graph g = new Graph(); List<String> missingFiles = new ArrayList<String>(); for (String gfile : grammarFileNames) { String grammarName = grammar.getGrammarName(); if ( vocabName!=null ) g.addEdge(gfile, vocabName+CodeGenerator.VOCAB_FILE_EXTENSION); g.addEdge(grammarName+CodeGenerator.VOCAB_FILE_EXTENSION, gfile); List<Object> sorted = g.sort();
public void sortGrammarFiles() throws IOException { Graph g = new Graph(); List<String> missingFiles = new ArrayList<String>(); for (String gfile : grammarFileNames) { String grammarName = grammar.getGrammarName(); if ( vocabName!=null ) g.addEdge(gfile, vocabName+CodeGenerator.VOCAB_FILE_EXTENSION); g.addEdge(grammarName+CodeGenerator.VOCAB_FILE_EXTENSION, gfile); List<Object> sorted = g.sort();
public void DFS(Node<T> n, Set<Node<T>> visited, ArrayList<T> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Node<T> target : n.edges) { DFS(target, visited, sorted); } } sorted.add(n.payload); } }
public void sortGrammarFiles() throws IOException { Graph<String> g = new Graph<String>(); List<String> missingFiles = new ArrayList<String>(); for (String gfile : grammarFileNames) { String grammarName = grammar.getGrammarName(); if ( vocabName!=null ) g.addEdge(gfile, vocabName+CodeGenerator.VOCAB_FILE_EXTENSION); g.addEdge(grammarName+CodeGenerator.VOCAB_FILE_EXTENSION, gfile); List<String> sorted = g.sort();
public void DFS(Node n, Set<Node> visited, ArrayList<Object> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Iterator it = n.edges.iterator(); it.hasNext();) { Node target = (Node) it.next(); DFS(target, visited, sorted); } } sorted.add(n.payload); } }
public void DFS(Node n, Set<Node> visited, ArrayList<Object> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Iterator it = n.edges.iterator(); it.hasNext();) { Node target = (Node) it.next(); DFS(target, visited, sorted); } } sorted.add(n.payload); } }
/** DFS-based topological sort. A valid sort is the reverse of * the post-order DFA traversal. Amazingly simple but true. * For sorting, I'm not following convention here since ANTLR * needs the opposite. Here's what I assume for sorting: * * If there exists an edge u -> v then u depends on v and v * must happen before u. * * So if this gives nonreversed postorder traversal, I get the order * I want. */ public List<Object> sort() { Set<Node> visited = new HashSet<Node>(); ArrayList<Object> sorted = new ArrayList<Object>(); while ( visited.size() < nodes.size() ) { // pick any unvisited node, n Node n = null; for (Iterator it = nodes.values().iterator(); it.hasNext();) { n = (Node)it.next(); if ( !visited.contains(n) ) break; } DFS(n, visited, sorted); } return sorted; }
/** DFS-based topological sort. A valid sort is the reverse of * the post-order DFA traversal. Amazingly simple but true. * For sorting, I'm not following convention here since ANTLR * needs the opposite. Here's what I assume for sorting: * * If there exists an edge u → v then u depends on v and v * must happen before u. * * So if this gives nonreversed postorder traversal, I get the order * I want. */ public List<T> sort() { Set<Node<T>> visited = new OrderedHashSet<Node<T>>(); ArrayList<T> sorted = new ArrayList<T>(); while ( visited.size() < nodes.size() ) { // pick any unvisited node, n Node<T> n = null; for (Node<T> tNode : nodes.values()) { n = tNode; if ( !visited.contains(n) ) break; } DFS(n, visited, sorted); } return sorted; }
/** DFS-based topological sort. A valid sort is the reverse of * the post-order DFA traversal. Amazingly simple but true. * For sorting, I'm not following convention here since ANTLR * needs the opposite. Here's what I assume for sorting: * * If there exists an edge u -> v then u depends on v and v * must happen before u. * * So if this gives nonreversed postorder traversal, I get the order * I want. */ public List<Object> sort() { Set<Node> visited = new OrderedHashSet<Node>(); ArrayList<Object> sorted = new ArrayList<Object>(); while ( visited.size() < nodes.size() ) { // pick any unvisited node, n Node n = null; for (Iterator it = nodes.values().iterator(); it.hasNext();) { n = (Node)it.next(); if ( !visited.contains(n) ) break; } DFS(n, visited, sorted); } return sorted; }
/** DFS-based topological sort. A valid sort is the reverse of * the post-order DFA traversal. Amazingly simple but true. * For sorting, I'm not following convention here since ANTLR * needs the opposite. Here's what I assume for sorting: * * If there exists an edge u → v then u depends on v and v * must happen before u. * * So if this gives nonreversed postorder traversal, I get the order * I want. */ public List<T> sort() { Set<Node<T>> visited = new OrderedHashSet<Node<T>>(); ArrayList<T> sorted = new ArrayList<T>(); while ( visited.size() < nodes.size() ) { // pick any unvisited node, n Node<T> n = null; for (Node<T> tNode : nodes.values()) { n = tNode; if ( !visited.contains(n) ) break; } DFS(n, visited, sorted); } return sorted; }