Cleaned up the graph classes

Author: phishman3579

src/com/jwetherell/algorithms/graph/BellmanFord.java

@@ -4,7 +4,6 @@
 importjava.util.LinkedHashSet;
 importjava.util.Map;
 importjava.util.Set;
-importjava.util.TreeMap;
 
 importcom.jwetherell.algorithms.data_structures.Graph;
 
@@ -44,11 +43,11 @@ public static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> graph,
 costs = null;
 paths = null;
 
-paths = newTreeMap<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>>();
+paths = newHashMap<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>>();
 for (Graph.Vertex<Integer> v : graph.getVerticies())
 paths.put(v, newLinkedHashSet<Graph.Edge<Integer>>());
 
-costs = newTreeMap<Graph.Vertex<Integer>, Graph.CostVertexPair<Integer>>();
+costs = newHashMap<Graph.Vertex<Integer>, Graph.CostVertexPair<Integer>>();
 for (Graph.Vertex<Integer> v : graph.getVerticies())
 if (v.equals(start))
 costs.put(v, newGraph.CostVertexPair<Integer>(0, v));

src/com/jwetherell/algorithms/graph/CycleDetection.java

@@ -11,15 +11,24 @@ public class CycleDetection {
 privatestaticSet<Graph.Vertex<Integer>> visitedVerticies = newHashSet<Graph.Vertex<Integer>>();
 privatestaticSet<Graph.Edge<Integer>> visitedEdges = newHashSet<Graph.Edge<Integer>>();
 
-privateCycleDetection() {
- };
+privateCycleDetection() { }
+
+/**
+ * Cycle detection on a unidrected graph.
+ * 
+ * @param graph Graph
+ * @return true if a cycle exists
+ */
+publicstaticbooleandetect(Graph<Integer> graph) {
+if (graph == null)
+thrownewIllegalArgumentException("Graph is NULL.");
+
+if (graph.getType() != Graph.TYPE.UNDIRECTED)
+thrownewIllegalArgumentException("Graph is needs to be Undirected.");
 
-publicstaticbooleandetect(Graph<Integer> g) {
-if (g == null)
-returnfalse;
 visitedVerticies.clear();
 visitedEdges.clear();
-List<Graph.Vertex<Integer>> verticies = g.getVerticies();
+List<Graph.Vertex<Integer>> verticies = graph.getVerticies();
 if (verticies == null || verticies.size() == 0)
 returnfalse;
 

src/com/jwetherell/algorithms/graph/Dijkstra.java

@@ -7,7 +7,6 @@
 importjava.util.PriorityQueue;
 importjava.util.Queue;
 importjava.util.Set;
-importjava.util.TreeMap;
 
 importcom.jwetherell.algorithms.data_structures.Graph;
 
@@ -53,11 +52,11 @@ public static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> graph,
 if (hasNegativeEdge)
 throw (newIllegalArgumentException("Negative cost Edges are not allowed."));
 
-paths = newTreeMap<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>>();
+paths = newHashMap<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>>();
 for (Graph.Vertex<Integer> v : graph.getVerticies())
 paths.put(v, newLinkedHashSet<Graph.Edge<Integer>>());
 
-costs = newTreeMap<Graph.Vertex<Integer>, Graph.CostVertexPair<Integer>>();
+costs = newHashMap<Graph.Vertex<Integer>, Graph.CostVertexPair<Integer>>();
 for (Graph.Vertex<Integer> v : graph.getVerticies()) {
 if (v.equals(start))
 costs.put(v, newGraph.CostVertexPair<Integer>(0, v));

src/com/jwetherell/algorithms/graph/FloydWarshall.java

@@ -19,10 +19,13 @@ public class FloydWarshall {
 privateFloydWarshall() {
  }
 
-publicstaticMap<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Integer>> getAllPairsShortestPaths(Graph<Integer> g) {
+publicstaticMap<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Integer>> getAllPairsShortestPaths(Graph<Integer> graph) {
+if (graph == null)
+throw (newNullPointerException("Graph must be non-NULL."));
+
 Map<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Integer>> allShortestPaths = newHashMap<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Integer>>();
 
-List<Graph.Vertex<Integer>> vertices = g.getVerticies();
+List<Graph.Vertex<Integer>> vertices = graph.getVerticies();
 int[][] sums = newint[vertices.size()][vertices.size()];
 
 for (inti = 0; i < sums.length; i++) {
@@ -31,7 +34,7 @@ public static Map<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Integer>> ge
  }
  }
 
-List<Graph.Edge<Integer>> edges = g.getEdges();
+List<Graph.Edge<Integer>> edges = graph.getEdges();
 for (Graph.Edge<Integer> e : edges) {
 intindexOfFrom = vertices.indexOf(e.getFromVertex());
 intindexOfTo = vertices.indexOf(e.getToVertex());

src/com/jwetherell/algorithms/graph/Johnson.java

@@ -20,6 +20,9 @@ public class Johnson {
 privateJohnson() { }
 
 publicstaticMap<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>>> getAllPairsShortestPaths(Graph<Integer> g) {
+if (g == null)
+throw (newNullPointerException("Graph must be non-NULL."));
+
 Map<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>>> allShortestPaths = 
 newHashMap<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>>>();
 

src/com/jwetherell/algorithms/graph/Prim.java

@@ -25,8 +25,8 @@ public class Prim {
 
 privatePrim() { }
 
-publicstaticGraph.CostPathPair<Integer> getMinimumSpanningTree(Graph<Integer> g, Graph.Vertex<Integer> start) {
-if (g == null)
+publicstaticGraph.CostPathPair<Integer> getMinimumSpanningTree(Graph<Integer> graph, Graph.Vertex<Integer> start) {
+if (graph == null)
 throw (newNullPointerException("Graph must be non-NULL."));
 
 // Reset variables
@@ -36,12 +36,13 @@ public static Graph.CostPathPair<Integer> getMinimumSpanningTree(Graph<Integer>
 edgesAvailable = null;
 
 // Prim's algorithm only works on undirected graphs
-if (g.getType() == Graph.TYPE.DIRECTED) throw (newIllegalArgumentException("Undirected graphs only."));
+if (graph.getType() == Graph.TYPE.DIRECTED) 
+throw (newIllegalArgumentException("Undirected graphs only."));
 
 path = newLinkedHashSet<Graph.Edge<Integer>>();
 
 unvisited = newArrayList<Graph.Vertex<Integer>>();
-unvisited.addAll(g.getVerticies());
+unvisited.addAll(graph.getVerticies());
 unvisited.remove(start);
 
 edgesAvailable = newPriorityQueue<Graph.Edge<Integer>>();

src/com/jwetherell/algorithms/graph/TopologicalSort.java

@@ -2,6 +2,7 @@
 
 importjava.util.ArrayList;
 importjava.util.List;
+importjava.util.concurrent.CopyOnWriteArrayList;
 
 importcom.jwetherell.algorithms.data_structures.Graph;
 
@@ -14,33 +15,47 @@
  */
 publicclassTopologicalSort {
 
-privateTopologicalSort() {
- };
+privateTopologicalSort() { }
 
+/**
+ * Performs a topological sort on a directed graph. Returns NULL if a cycle is detected.
+ * 
+ * @param graph
+ * @return Sorted List of Vertices or NULL if graph has a cycle
+ */
 publicstaticfinalList<Graph.Vertex<Integer>> sort(Graph<Integer> graph) {
+if (graph == null)
+thrownewIllegalArgumentException("Graph is NULL.");
+
+if (graph.getType() != Graph.TYPE.DIRECTED)
+thrownewIllegalArgumentException("Cannot perform a topological sort on a non-directed graph. graph type = "+graph.getType());
+
 List<Graph.Vertex<Integer>> sorted = newArrayList<Graph.Vertex<Integer>>();
 List<Graph.Vertex<Integer>> noOutgoing = newArrayList<Graph.Vertex<Integer>>();
+
+List<Graph.Edge<Integer>> edges = newCopyOnWriteArrayList<Graph.Edge<Integer>>();
+edges.addAll(graph.getEdges());
+
 for (Graph.Vertex<Integer> v : graph.getVerticies()) {
-if (v.getEdges().size() == 0) {
+if (v.getEdges().size() == 0)
 noOutgoing.add(v);
- }
  }
 while (noOutgoing.size() > 0) {
 Graph.Vertex<Integer> v = noOutgoing.remove(0);
 sorted.add(v);
-for (Graph.Edge<Integer> e : graph.getEdges()) {
+for (Graph.Edge<Integer> e : edges) {
 Graph.Vertex<Integer> v2 = e.getFromVertex();
 Graph.Vertex<Integer> v3 = e.getToVertex();
 if (v3.equals(v)) {
-graph.getEdges().remove(e);
+edges.remove(e);
 v2.getEdges().remove(e);
  }
 if (v2.getEdges().size() == 0)
 noOutgoing.add(v2);
  }
  }
-if (graph.getEdges().size() > 0)
-System.out.println("cycle detected");
+if (edges.size() > 0)
+returnnull;
 returnsorted;
  }
 }