Java tutorial
package edu.stanford.nlp.graph; import java.util.*; import edu.stanford.nlp.util.CollectionUtils; import edu.stanford.nlp.util.Generics; import edu.stanford.nlp.util.MapFactory; /** * Simple graph library; this is directed for now. This class focuses on time * efficiency rather than memory efficiency. * * @author sonalg * @author John Bauer * * @param <V> * Type of vertices * @param <E> * Type of edges. */ public class DirectedMultiGraph<V, E> implements Graph<V, E> /* Serializable */ { final Map<V, Map<V, List<E>>> outgoingEdges; final Map<V, Map<V, List<E>>> incomingEdges; final MapFactory<V, Map<V, List<E>>> outerMapFactory; final MapFactory<V, List<E>> innerMapFactory; public DirectedMultiGraph() { this(MapFactory.<V, Map<V, List<E>>>hashMapFactory(), MapFactory.<V, List<E>>hashMapFactory()); } public DirectedMultiGraph(MapFactory<V, Map<V, List<E>>> outerMapFactory, MapFactory<V, List<E>> innerMapFactory) { this.outerMapFactory = outerMapFactory; this.innerMapFactory = innerMapFactory; this.outgoingEdges = outerMapFactory.newMap(); this.incomingEdges = outerMapFactory.newMap(); } /** * Creates a copy of the given graph. This will copy the entire data * structure (this may be slow!), but will not copy any of the edge * or vertex objects. * * @param graph The graph to copy into this object. */ public DirectedMultiGraph(DirectedMultiGraph<V, E> graph) { this(graph.outerMapFactory, graph.innerMapFactory); for (Map.Entry<V, Map<V, List<E>>> map : graph.outgoingEdges.entrySet()) { Map<V, List<E>> edgesCopy = innerMapFactory.newMap(); for (Map.Entry<V, List<E>> entry : map.getValue().entrySet()) { edgesCopy.put(entry.getKey(), Generics.newArrayList(entry.getValue())); } this.outgoingEdges.put(map.getKey(), edgesCopy); } for (Map.Entry<V, Map<V, List<E>>> map : graph.incomingEdges.entrySet()) { Map<V, List<E>> edgesCopy = innerMapFactory.newMap(); for (Map.Entry<V, List<E>> entry : map.getValue().entrySet()) { edgesCopy.put(entry.getKey(), Generics.newArrayList(entry.getValue())); } this.incomingEdges.put(map.getKey(), edgesCopy); } } /** * Be careful hashing these. They are mutable objects, and changing the object * will throw off the hash code, messing up your hash table */ public int hashCode() { return outgoingEdges.hashCode(); } public boolean equals(Object that) { if (that == this) return true; if (!(that instanceof DirectedMultiGraph)) return false; return outgoingEdges.equals(((DirectedMultiGraph<?, ?>) that).outgoingEdges); } /** * For adding a zero degree vertex * * @param v */ @Override public boolean addVertex(V v) { if (outgoingEdges.containsKey(v)) return false; outgoingEdges.put(v, innerMapFactory.newMap()); incomingEdges.put(v, innerMapFactory.newMap()); return true; } private Map<V, List<E>> getOutgoingEdgesMap(V v) { Map<V, List<E>> map = outgoingEdges.get(v); if (map == null) { map = innerMapFactory.newMap(); outgoingEdges.put(v, map); incomingEdges.put(v, innerMapFactory.newMap()); } return map; } private Map<V, List<E>> getIncomingEdgesMap(V v) { Map<V, List<E>> map = incomingEdges.get(v); if (map == null) { outgoingEdges.put(v, innerMapFactory.newMap()); map = innerMapFactory.newMap(); incomingEdges.put(v, map); } return map; } /** * adds vertices (if not already in the graph) and the edge between them * * @param source * @param dest * @param data */ @Override public void add(V source, V dest, E data) { Map<V, List<E>> outgoingMap = getOutgoingEdgesMap(source); Map<V, List<E>> incomingMap = getIncomingEdgesMap(dest); List<E> outgoingList = outgoingMap.get(dest); if (outgoingList == null) { outgoingList = new ArrayList<>(); outgoingMap.put(dest, outgoingList); } List<E> incomingList = incomingMap.get(source); if (incomingList == null) { incomingList = new ArrayList<>(); incomingMap.put(source, incomingList); } outgoingList.add(data); incomingList.add(data); } @Override public boolean removeEdges(V source, V dest) { if (!outgoingEdges.containsKey(source)) { return false; } if (!incomingEdges.containsKey(dest)) { return false; } if (!outgoingEdges.get(source).containsKey(dest)) { return false; } outgoingEdges.get(source).remove(dest); incomingEdges.get(dest).remove(source); return true; } @Override public boolean removeEdge(V source, V dest, E data) { if (!outgoingEdges.containsKey(source)) { return false; } if (!incomingEdges.containsKey(dest)) { return false; } if (!outgoingEdges.get(source).containsKey(dest)) { return false; } boolean foundOut = outgoingEdges.containsKey(source) && outgoingEdges.get(source).containsKey(dest) && outgoingEdges.get(source).get(dest).remove(data); boolean foundIn = incomingEdges.containsKey(dest) && incomingEdges.get(dest).containsKey(source) && incomingEdges.get(dest).get(source).remove(data); if (foundOut && !foundIn) { throw new AssertionError("Edge found in outgoing but not incoming"); } if (foundIn && !foundOut) { throw new AssertionError("Edge found in incoming but not outgoing"); } // TODO: cut down the number of .get calls if (outgoingEdges.containsKey(source) && (!outgoingEdges.get(source).containsKey(dest) || outgoingEdges.get(source).get(dest).size() == 0)) { outgoingEdges.get(source).remove(dest); } if (incomingEdges.containsKey(dest) && (!incomingEdges.get(dest).containsKey(source) || incomingEdges.get(dest).get(source).size() == 0)) { incomingEdges.get(dest).remove(source); } return foundOut; } /** * remove a vertex (and its edges) from the graph. * * @param vertex * @return true if successfully removes the node */ @Override public boolean removeVertex(V vertex) { if (!outgoingEdges.containsKey(vertex)) { return false; } for (V other : outgoingEdges.get(vertex).keySet()) { incomingEdges.get(other).remove(vertex); } for (V other : incomingEdges.get(vertex).keySet()) { outgoingEdges.get(other).remove(vertex); } outgoingEdges.remove(vertex); incomingEdges.remove(vertex); return true; } @Override public boolean removeVertices(Collection<V> vertices) { boolean changed = false; for (V v : vertices) { if (removeVertex(v)) { changed = true; } } return changed; } @Override public int getNumVertices() { return outgoingEdges.size(); } @Override public List<E> getOutgoingEdges(V v) { if (!outgoingEdges.containsKey(v)) { //noinspection unchecked return Collections.emptyList(); } return CollectionUtils.flatten(outgoingEdges.get(v).values()); } @Override public List<E> getIncomingEdges(V v) { if (!incomingEdges.containsKey(v)) { //noinspection unchecked return Collections.emptyList(); } return CollectionUtils.flatten(incomingEdges.get(v).values()); } @Override public int getNumEdges() { int count = 0; for (Map.Entry<V, Map<V, List<E>>> sourceEntry : outgoingEdges.entrySet()) { for (Map.Entry<V, List<E>> destEntry : sourceEntry.getValue().entrySet()) { count += destEntry.getValue().size(); } } return count; } @Override public Set<V> getParents(V vertex) { Map<V, List<E>> parentMap = incomingEdges.get(vertex); if (parentMap == null) return null; return Collections.unmodifiableSet(parentMap.keySet()); } @Override public Set<V> getChildren(V vertex) { Map<V, List<E>> childMap = outgoingEdges.get(vertex); if (childMap == null) return null; return Collections.unmodifiableSet(childMap.keySet()); } /** * Gets both parents and children nodes * * @param v */ @Override public Set<V> getNeighbors(V v) { // TODO: pity we have to copy the sets... is there a combination set? Set<V> children = getChildren(v); Set<V> parents = getParents(v); if (children == null && parents == null) return null; Set<V> neighbors = innerMapFactory.newSet(); neighbors.addAll(children); neighbors.addAll(parents); return neighbors; } /** * clears the graph, removes all edges and nodes */ @Override public void clear() { incomingEdges.clear(); outgoingEdges.clear(); } @Override public boolean containsVertex(V v) { return outgoingEdges.containsKey(v); } /** * only checks if there is an edge from source to dest. To check if it is * connected in either direction, use isNeighbor * * @param source * @param dest */ @Override public boolean isEdge(V source, V dest) { Map<V, List<E>> childrenMap = outgoingEdges.get(source); if (childrenMap == null || childrenMap.isEmpty()) return false; List<E> edges = childrenMap.get(dest); if (edges == null || edges.isEmpty()) return false; return edges.size() > 0; } @Override public boolean isNeighbor(V source, V dest) { return isEdge(source, dest) || isEdge(dest, source); } @Override public Set<V> getAllVertices() { return Collections.unmodifiableSet(outgoingEdges.keySet()); } @Override public List<E> getAllEdges() { List<E> edges = new ArrayList<>(); for (Map<V, List<E>> e : outgoingEdges.values()) { for (List<E> ee : e.values()) { edges.addAll(ee); } } return edges; } /** * False if there are any vertices in the graph, true otherwise. Does not care * about the number of edges. */ @Override public boolean isEmpty() { return outgoingEdges.isEmpty(); } /** * Deletes nodes with zero incoming and zero outgoing edges */ @Override public void removeZeroDegreeNodes() { List<V> toDelete = new ArrayList<>(); for (V vertex : outgoingEdges.keySet()) { if (outgoingEdges.get(vertex).isEmpty() && incomingEdges.get(vertex).isEmpty()) { toDelete.add(vertex); } } for (V vertex : toDelete) { outgoingEdges.remove(vertex); incomingEdges.remove(vertex); } } @Override public List<E> getEdges(V source, V dest) { Map<V, List<E>> childrenMap = outgoingEdges.get(source); if (childrenMap == null) { return Collections.emptyList(); } List<E> edges = childrenMap.get(dest); if (edges == null) { return Collections.emptyList(); } return Collections.unmodifiableList(edges); } /** * direction insensitive (the paths can go "up" or through the parents) */ public List<V> getShortestPath(V node1, V node2) { if (!outgoingEdges.containsKey(node1) || !outgoingEdges.containsKey(node2)) { return null; } return getShortestPath(node1, node2, false); } public List<E> getShortestPathEdges(V node1, V node2) { return convertPath(getShortestPath(node1, node2), false); } /** * can specify the direction sensitivity * * @param node1 * @param node2 * @param directionSensitive * - whether the path can go through the parents * @return the list of nodes you get through to get there */ public List<V> getShortestPath(V node1, V node2, boolean directionSensitive) { if (!outgoingEdges.containsKey(node1) || !outgoingEdges.containsKey(node2)) { return null; } return DijkstraShortestPath.getShortestPath(this, node1, node2, directionSensitive); } public List<E> getShortestPathEdges(V node1, V node2, boolean directionSensitive) { return convertPath(getShortestPath(node1, node2, directionSensitive), directionSensitive); } public List<E> convertPath(List<V> nodes, boolean directionSensitive) { if (nodes == null) return null; if (nodes.size() <= 1) return Collections.emptyList(); List<E> path = new ArrayList<>(); Iterator<V> nodeIterator = nodes.iterator(); V previous = nodeIterator.next(); while (nodeIterator.hasNext()) { V next = nodeIterator.next(); E connection = null; List<E> edges = getEdges(previous, next); if (edges.size() == 0 && !directionSensitive) { edges = getEdges(next, previous); } if (edges.size() > 0) { connection = edges.get(0); } else { throw new IllegalArgumentException("Path given with missing " + "edge connection"); } path.add(connection); previous = next; } return path; } @Override public int getInDegree(V vertex) { if (!containsVertex(vertex)) { return 0; } int result = 0; Map<V, List<E>> incoming = incomingEdges.get(vertex); for (List<E> edges : incoming.values()) { result += edges.size(); } return result; } @Override public int getOutDegree(V vertex) { int result = 0; Map<V, List<E>> outgoing = outgoingEdges.get(vertex); if (outgoing == null) { return 0; } for (List<E> edges : outgoing.values()) { result += edges.size(); } return result; } @Override public List<Set<V>> getConnectedComponents() { return ConnectedComponents.getConnectedComponents(this); } /** * Deletes all duplicate edges. */ public void deleteDuplicateEdges() { for (V vertex : getAllVertices()) { for (V vertex2 : outgoingEdges.get(vertex).keySet()) { List<E> data = outgoingEdges.get(vertex).get(vertex2); Set<E> deduplicatedData = new TreeSet<>(data); data.clear(); data.addAll(deduplicatedData); } for (V vertex2 : incomingEdges.get(vertex).keySet()) { List<E> data = incomingEdges.get(vertex).get(vertex2); Set<E> deduplicatedData = new TreeSet<>(data); data.clear(); data.addAll(deduplicatedData); } } } public Iterator<E> incomingEdgeIterator(final V vertex) { return new EdgeIterator<>(vertex, incomingEdges, outgoingEdges); } public Iterable<E> incomingEdgeIterable(final V vertex) { return () -> new EdgeIterator<>(vertex, incomingEdges, outgoingEdges); } public Iterator<E> outgoingEdgeIterator(final V vertex) { return new EdgeIterator<>(vertex, outgoingEdges, incomingEdges); } public Iterable<E> outgoingEdgeIterable(final V vertex) { return () -> new EdgeIterator<>(vertex, outgoingEdges, incomingEdges); } public Iterator<E> edgeIterator() { return new EdgeIterator<>(this); } public Iterable<E> edgeIterable() { return () -> new EdgeIterator<>(DirectedMultiGraph.this); } /** * This class handles either iterating over a single vertex's * connections or over all connections in a graph. */ static class EdgeIterator<V, E> implements Iterator<E> { private final Map<V, Map<V, List<E>>> reverseEdges; /** when iterating over the whole graph, this iterates over nodes */ private Iterator<Map.Entry<V, Map<V, List<E>>>> vertexIterator; /** for a given node, this iterates over its neighbors */ private Iterator<Map.Entry<V, List<E>>> connectionIterator; /** given the neighbor of a node, this iterates over all its connections */ private Iterator<E> edgeIterator; private V currentSource = null; private V currentTarget = null; private E currentEdge = null; private boolean hasNext = true; public EdgeIterator(DirectedMultiGraph<V, E> graph) { vertexIterator = graph.outgoingEdges.entrySet().iterator(); reverseEdges = graph.incomingEdges; } public EdgeIterator(V startVertex, Map<V, Map<V, List<E>>> source, Map<V, Map<V, List<E>>> reverseEdges) { currentSource = startVertex; Map<V, List<E>> neighbors = source.get(startVertex); if (neighbors != null) { vertexIterator = null; connectionIterator = neighbors.entrySet().iterator(); } this.reverseEdges = reverseEdges; } @Override public boolean hasNext() { primeIterator(); return hasNext; } @Override public E next() { if (!hasNext()) { throw new NoSuchElementException("Graph edge iterator exhausted."); } currentEdge = edgeIterator.next(); return currentEdge; } private void primeIterator() { if (edgeIterator != null && edgeIterator.hasNext()) { hasNext = true; // technically, we shouldn't need to put this here, but let's be safe } else if (connectionIterator != null && connectionIterator.hasNext()) { Map.Entry<V, List<E>> nextConnection = connectionIterator.next(); edgeIterator = nextConnection.getValue().iterator(); currentTarget = nextConnection.getKey(); primeIterator(); } else if (vertexIterator != null && vertexIterator.hasNext()) { Map.Entry<V, Map<V, List<E>>> nextVertex = vertexIterator.next(); connectionIterator = nextVertex.getValue().entrySet().iterator(); currentSource = nextVertex.getKey(); primeIterator(); } else { hasNext = false; } } @Override public void remove() { if (currentEdge != null) { reverseEdges.get(currentTarget).get(currentSource).remove(currentEdge); edgeIterator.remove(); if (reverseEdges.get(currentTarget).get(currentSource) != null && reverseEdges.get(currentTarget).get(currentSource).size() == 0) { connectionIterator.remove(); reverseEdges.get(currentTarget).remove(currentSource); // TODO: may not be necessary to set this to null edgeIterator = null; } } } } /** * Topological sort of the graph. * <br> * This method uses the depth-first search implementation of * topological sort. * Topological sorting only works if the graph is acyclic. * * @return A sorted list of the vertices * @throws IllegalStateException if this graph is not a DAG */ public List<V> topologicalSort() { List<V> result = Generics.newArrayList(); Set<V> temporary = outerMapFactory.newSet(); Set<V> permanent = outerMapFactory.newSet(); for (V vertex : getAllVertices()) { if (!temporary.contains(vertex)) { topologicalSortHelper(vertex, temporary, permanent, result); } } Collections.reverse(result); return result; } private void topologicalSortHelper(V vertex, Set<V> temporary, Set<V> permanent, List<V> result) { temporary.add(vertex); Map<V, List<E>> neighborMap = outgoingEdges.get(vertex); if (neighborMap != null) { for (V neighbor : neighborMap.keySet()) { if (permanent.contains(neighbor)) { continue; } if (temporary.contains(neighbor)) { throw new IllegalStateException( "This graph has cycles. Topological sort not possible: " + this.toString()); } topologicalSortHelper(neighbor, temporary, permanent, result); } } result.add(vertex); permanent.add(vertex); } /** * Cast this multi-graph as a map from vertices, to the outgoing data along edges out of those vertices. * * @return A map representation of the graph. */ public Map<V, List<E>> toMap() { Map<V, List<E>> map = innerMapFactory.newMap(); for (V vertex : getAllVertices()) { map.put(vertex, getOutgoingEdges(vertex)); } return map; } @Override public String toString() { StringBuilder s = new StringBuilder(); s.append("{\n"); s.append("Vertices:\n"); for (V vertex : outgoingEdges.keySet()) { s.append(" ").append(vertex).append('\n'); } s.append("Edges:\n"); for (V source : outgoingEdges.keySet()) { for (V dest : outgoingEdges.get(source).keySet()) { for (E edge : outgoingEdges.get(source).get(dest)) { s.append(" ").append(source).append(" -> ").append(dest).append(" : ").append(edge) .append('\n'); } } } s.append('}'); return s.toString(); } private static final long serialVersionUID = 609823567298345145L; }