Reset variables in static graph based methods

git-svn-id: https://java-algorithms-implementation.googlecode.com/svn/trunk@382 032fbc0f-8cab-eb90-e552-f08422b9a96a

Author: phishman3579

src/com/jwetherell/algorithms/DataStructures.java

@@ -61,14 +61,14 @@ public class DataStructures {
     private static Integer[] sorted = null;
     private static String string = null;
 
-    private static int debug = 1; // Debug level. 0=None, 1=Time and Memory (if
+    private static int debug = 0; // Debug level. 0=None, 1=Time and Memory (if
                                   // enabled), 2=Time, Memory, data structure
                                   // debug
-    private static boolean debugTime = true; // How much time to: add all,
-                                             // remove all, add all items in
-                                             // reverse order, remove all
-    private static boolean debugMemory = true; // How much memory is used by the
-                                               // data structure
+    private static boolean debugTime = false; // How much time to: add all,
+                                              // remove all, add all items in
+                                              // reverse order, remove all
+    private static boolean debugMemory = false; // How much memory is used by the
+                                                // data structure
     private static boolean validateStructure = true; // Is the data structure
                                                      // valid (passed
                                                      // invariants) and proper
@@ -1518,6 +1518,44 @@ private static boolean testGraph() {
             if (debug > 1)
                 System.out.println(pair.toString());
 
+            // Prim on a graph with cycles
+            java.util.List<Vertex<Integer>> cyclicVerticies = new ArrayList<Vertex<Integer>>();
+            Graph.Vertex<Integer> cv1 = new Graph.Vertex<Integer>(1);
+            cyclicVerticies.add(cv1);
+            Graph.Vertex<Integer> cv2 = new Graph.Vertex<Integer>(2);
+            cyclicVerticies.add(cv2);
+            Graph.Vertex<Integer> cv3 = new Graph.Vertex<Integer>(3);
+            cyclicVerticies.add(cv3);
+            Graph.Vertex<Integer> cv4 = new Graph.Vertex<Integer>(4);
+            cyclicVerticies.add(cv4);
+            Graph.Vertex<Integer> cv5 = new Graph.Vertex<Integer>(5);
+            cyclicVerticies.add(cv5);
+
+            java.util.List<Edge<Integer>> cyclicEdges = new ArrayList<Edge<Integer>>();
+            Graph.Edge<Integer> ce1_2 = new Graph.Edge<Integer>(3, cv1, cv2);
+            cyclicEdges.add(ce1_2);
+            Graph.Edge<Integer> ce2_3 = new Graph.Edge<Integer>(2, cv2, cv3);
+            cyclicEdges.add(ce2_3);
+            Graph.Edge<Integer> ce3_4 = new Graph.Edge<Integer>(4, cv3, cv4);
+            cyclicEdges.add(ce3_4);
+            Graph.Edge<Integer> ce4_1 = new Graph.Edge<Integer>(1, cv4, cv1);
+            cyclicEdges.add(ce4_1);
+            Graph.Edge<Integer> ce4_5 = new Graph.Edge<Integer>(1, cv4, cv5);
+            cyclicEdges.add(ce4_5);
+
+            Graph<Integer> cyclicUndirected = new Graph<Integer>(cyclicVerticies, cyclicEdges);
+            if (debug > 1)
+                System.out.println(cyclicUndirected.toString());
+
+            start = cv1;
+            System.out.println(start.toString());
+            if (debug > 1)
+                System.out.println("Prim's minimum spanning tree of a cyclic undirected graph from " + start.getValue());
+            Graph.CostPathPair<Integer> cyclicPair = Prim.getMinimumSpanningTree(cyclicUndirected, start);
+            System.out.println(cyclicPair.toString());
+            if (debug > 1)
+                System.out.println(cyclicPair.toString());
+
             if (debug > 1)
                 System.out.println();
         }
@@ -1590,8 +1628,7 @@ private static boolean testGraph() {
             start = v1;
             if (debug > 1)
                 System.out.println("Bellman-Ford's shortest paths of the undirected graph from " + start.getValue());
-            Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> map2 = BellmanFord
-                    .getShortestPaths(directed, start);
+            Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> map2 = BellmanFord.getShortestPaths(directed, start);
             if (debug > 1)
                 System.out.println(getPathMapString(start, map2));
 

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

@@ -23,11 +23,9 @@ public class BellmanFord {
     private static Map<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>> paths = null;
     private static boolean containsNegativeWeightCycle = false;
 
-    private BellmanFord() {
-    }
+    private BellmanFord() { }
 
-    public static Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> getShortestPaths(Graph<Integer> g,
-            Graph.Vertex<Integer> start) {
+    public static Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> getShortestPaths(Graph<Integer> g, Graph.Vertex<Integer> start) {
         getShortestPath(g, start, null);
         Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> map = new HashMap<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>>();
         for (Graph.CostVertexPair<Integer> pair : costs.values()) {
@@ -39,11 +37,13 @@ public static Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> getShortes
         return map;
     }
 
-    public static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> g, Graph.Vertex<Integer> start,
-            Graph.Vertex<Integer> end) {
+    public static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> g, Graph.Vertex<Integer> start, Graph.Vertex<Integer> end) {
         if (g == null)
             throw (new NullPointerException("Graph must be non-NULL."));
 
+        // Reset variables
+        costs = null;
+        paths = null;
         containsNegativeWeightCycle = false;
 
         paths = new TreeMap<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>>();

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

@@ -25,11 +25,9 @@ public class Dijkstra {
     private static Map<Graph.Vertex<Integer>, Set<Graph.Edge<Integer>>> paths = null;
     private static Queue<Graph.CostVertexPair<Integer>> unvisited = null;
 
-    private Dijkstra() {
-    }
+    private Dijkstra() { }
 
-    public static Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> getShortestPaths(Graph<Integer> g,
-            Graph.Vertex<Integer> start) {
+    public static Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> getShortestPaths(Graph<Integer> g, Graph.Vertex<Integer> start) {
         getShortestPath(g, start, null);
         Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> map = new HashMap<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>>();
         for (Graph.CostVertexPair<Integer> pair : costs.values()) {
@@ -41,11 +39,15 @@ public static Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> getShortes
         return map;
     }
 
-    public static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> g, Graph.Vertex<Integer> start,
-            Graph.Vertex<Integer> end) {
+    public static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> g, Graph.Vertex<Integer> start, Graph.Vertex<Integer> end) {
         if (g == null)
             throw (new NullPointerException("Graph must be non-NULL."));
 
+        // Reset variables
+        costs = null;
+        paths = null;
+        unvisited = null;
+
         // Dijkstra's algorithm only works on positive cost graphs
         boolean hasNegativeEdge = checkForNegativeEdges(g.getVerticies());
         if (hasNegativeEdge)

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

@@ -23,16 +23,20 @@ public class Prim {
     private static List<Graph.Vertex<Integer>> unvisited = null;
     private static Queue<Graph.Edge<Integer>> edgesAvailable = null;
 
-    private Prim() {
-    }
+    private Prim() { }
 
     public static Graph.CostPathPair<Integer> getMinimumSpanningTree(Graph<Integer> g, Graph.Vertex<Integer> start) {
         if (g == null)
             throw (new NullPointerException("Graph must be non-NULL."));
 
+        // Reset variables
+        cost = 0;
+        path = null;
+        unvisited = null;
+        edgesAvailable = null;
+
         // Prim's algorithm only works on undirected graphs
-        if (g.getType() == Graph.TYPE.DIRECTED)
-            throw (new IllegalArgumentException("Undirected graphs only."));
+        if (g.getType() == Graph.TYPE.DIRECTED) throw (new IllegalArgumentException("Undirected graphs only."));
 
         path = new LinkedHashSet<Graph.Edge<Integer>>();