Implemented a better deep copy of the Graph class and also added a equals/hashCode method

Author: Justin Wetherell

src/com/jwetherell/algorithms/data_structures/Graph.java

@@ -1,6 +1,7 @@
 package com.jwetherell.algorithms.data_structures;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
@@ -24,6 +25,7 @@ public enum TYPE {
         DIRECTED, UNDIRECTED
     }
 
+    /** Defaulted to undirected */
     private TYPE type = TYPE.UNDIRECTED;
 
     public Graph() { }
@@ -32,30 +34,47 @@ public Graph(TYPE type) {
         this.type = type;
     }
 
+    /** Deep copies **/
     public Graph(Graph<T> g) {
-        // Deep copies
-
         type = g.getType();
 
-        // Copy the vertices (which copies the edges)
-        for (Vertex<T> v : g.getVerticies())
+        // Copy the vertices which also copies the edges
+        for (Vertex<T> v : g.getVertices())
             this.allVertices.add(new Vertex<T>(v));
 
-        // New edges are created in the above loop, now add them to the graph's list
-        for (Vertex<T> v : this.allVertices) {
-            for (Edge<T> e : v.getEdges())
+        for (Vertex<T> v : this.getVertices()) {
+            for (Edge<T> e : v.getEdges()) {
                 this.allEdges.add(e);
+            }
         }
     }
 
-    public Graph(Collection<Vertex<T>> verticies, List<Edge<T>> edges) {
-        this(TYPE.UNDIRECTED, verticies, edges);
+    /**
+     * Creates a Graph from the vertices and edges. This defaults to an undirected Graph
+     * 
+     * NOTE: Duplicate vertices and edges ARE allowed.
+     * NOTE: Copies the vertex and edge objects but does NOT store the Collection parameters itself.
+     * 
+     * @param vertices Collection of vertices
+     * @param edges Collection of edges
+     */
+    public Graph(Collection<Vertex<T>> vertices, Collection<Edge<T>> edges) {
+        this(TYPE.UNDIRECTED, vertices, edges);
     }
 
-    public Graph(TYPE type, Collection<Vertex<T>> verticies, List<Edge<T>> edges) {
+    /**
+     * Creates a Graph from the vertices and edges.
+     * 
+     * NOTE: Duplicate vertices and edges ARE allowed.
+     * NOTE: Copies the vertex and edge objects but does NOT store the Collection parameters itself.
+     * 
+     * @param vertices Collection of vertices
+     * @param edges Collection of edges
+     */
+    public Graph(TYPE type, Collection<Vertex<T>> vertices, Collection<Edge<T>> edges) {
         this(type);
 
-        this.allVertices.addAll(verticies);
+        this.allVertices.addAll(vertices);
         this.allEdges.addAll(edges);
 
         for (Edge<T> e : edges) {
@@ -78,7 +97,7 @@ public TYPE getType() {
         return type;
     }
 
-    public List<Vertex<T>> getVerticies() {
+    public List<Vertex<T>> getVertices() {
         return allVertices;
     }
 
@@ -121,13 +140,29 @@ public boolean equals(Object g1) {
         if (!edgesSizeEquals)
             return false;
 
-        final boolean verticesEquals = this.allVertices.equals(g.allVertices);
-        if (!verticesEquals)
-            return false;
+        // Vertices can contain duplicates and appear in different order but both arrays should contain the same elements
+        final Object[] ov1 = this.allVertices.toArray();
+        Arrays.sort(ov1);
+        final Object[] ov2 = g.allVertices.toArray();
+        Arrays.sort(ov2);
+        for (int i=0; i<ov1.length; i++) {
+            final Vertex<T> v1 = (Vertex<T>) ov1[i];
+            final Vertex<T> v2 = (Vertex<T>) ov2[i];
+            if (!v1.equals(v2))
+                return false;
+        }
 
-        final boolean edgesEquals = this.allEdges.equals(g.allEdges);
-        if (!edgesEquals)
-            return false;
+        // Edges can contain duplicates and appear in different order but both arrays should contain the same elements
+        final Object[] oe1 = this.allEdges.toArray();
+        Arrays.sort(oe1);
+        final Object[] oe2 = g.allEdges.toArray();
+        Arrays.sort(oe2);
+        for (int i=0; i<oe1.length; i++) {
+            final Edge<T> e1 = (Edge<T>) oe1[i];
+            final Edge<T> e2 = (Edge<T>) oe2[i];
+            if (!e1.equals(e2))
+                return false;
+        }
 
         return true;
     }
@@ -158,13 +193,11 @@ public Vertex(T value, int weight) {
             this.weight = weight;
         }
 
-        /** Deep copies edges **/
+        /** Deep copies the edges along with the value and weight **/
         public Vertex(Vertex<T> vertex) {
             this(vertex.value, vertex.weight);
 
-            this.edges = new ArrayList<Edge<T>>();
-            for (Edge<T> e : vertex.edges)
-                this.edges.add(new Edge<T>(e));
+            this.edges.addAll(vertex.edges);
         }
 
         public T getValue() {
@@ -226,6 +259,16 @@ public boolean equals(Object v1) {
             if (!valuesEquals)
                 return false;
 
+            final Iterator<Edge<T>> iter1 = this.edges.iterator();
+            final Iterator<Edge<T>> iter2 = v.edges.iterator();
+            while (iter1.hasNext() && iter2.hasNext()) {
+                // Only checking the cost
+                final Edge<T> e1 = iter1.next();
+                final Edge<T> e2 = iter2.next();
+                if (e1.cost != e2.cost)
+                    return false;
+            }
+
             return true;
         }
 
@@ -234,9 +277,33 @@ public boolean equals(Object v1) {
          */
         @Override
         public int compareTo(Vertex<T> v) {
-            if (this.value == null || v.value == null)
+            final int valueComp = this.value.compareTo(v.value);
+            if (valueComp != 0)
+                return valueComp;
+
+            if (this.weight < v.weight)
                 return -1;
-            return this.value.compareTo(v.value);
+            if (this.weight > v.weight)
+                return 1;
+
+            if (this.edges.size() < v.edges.size())
+                return -1;
+            if (this.edges.size() > v.edges.size())
+                return 1;
+
+            final Iterator<Edge<T>> iter1 = this.edges.iterator();
+            final Iterator<Edge<T>> iter2 = v.edges.iterator();
+            while (iter1.hasNext() && iter2.hasNext()) {
+                // Only checking the cost
+                final Edge<T> e1 = iter1.next();
+                final Edge<T> e2 = iter2.next();
+                if (e1.cost < e2.cost)
+                    return -1;
+                if (e1.cost > e2.cost)
+                    return 1;
+            }
+
+            return 0;
         }
 
         /**
@@ -260,7 +327,7 @@ public static class Edge<T extends Comparable<T>> implements Comparable<Edge<T>>
 
         public Edge(int cost, Vertex<T> from, Vertex<T> to) {
             if (from == null || to == null)
-                throw (new NullPointerException("Both 'to' and 'from' Verticies need to be non-NULL."));
+                throw (new NullPointerException("Both 'to' and 'from' vertices need to be non-NULL."));
 
             this.cost = cost;
             this.from = from;
@@ -310,12 +377,12 @@ public boolean equals(Object e1) {
             if (!costs)
                 return false;
 
-            final boolean froms = this.from.equals(e.from);
-            if (!froms)
+            final boolean from = this.from.equals(e.from);
+            if (!from)
                 return false;
 
-            final boolean tos = this.to.equals(e.to);
-            if (!tos)
+            final boolean to = this.to.equals(e.to);
+            if (!to)
                 return false;
 
             return true;
@@ -330,6 +397,15 @@ public int compareTo(Edge<T> e) {
                 return -1;
             if (this.cost > e.cost)
                 return 1;
+
+            final int from = this.from.compareTo(e.from);
+            if (from != 0)
+                return from;
+
+            final int to = this.to.compareTo(e.to);
+            if (to != 0)
+                return to;
+
             return 0;
         }
 

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

@@ -74,21 +74,21 @@ private static void getShortestPath(Graph<Integer> graph,
         if (start == null)
             throw (new NullPointerException("start must be non-NULL."));
 
-        for (Graph.Vertex<Integer> v : graph.getVerticies())
+        for (Graph.Vertex<Integer> v : graph.getVertices())
             paths.put(v, new ArrayList<Graph.Edge<Integer>>());
 
         // All vertices are INFINITY unless it's the start vertices
-        for (Graph.Vertex<Integer> v : graph.getVerticies())
+        for (Graph.Vertex<Integer> v : graph.getVertices())
             if (v.equals(start))
                 costs.put(v, new Graph.CostVertexPair<Integer>(0, v));
             else
                 costs.put(v, new Graph.CostVertexPair<Integer>(Integer.MAX_VALUE, v));
 
         boolean negativeCycleCheck = false;
-        for (int i = 0; i < graph.getVerticies().size(); i++) {
+        for (int i = 0; i < graph.getVertices().size(); i++) {
             // If it's the last vertices, perform a negative weight cycle check.
             // The graph should be finished by the size()-1 time through this loop.
-            if (i == (graph.getVerticies().size() - 1))
+            if (i == (graph.getVertices().size() - 1))
                 negativeCycleCheck = true;
 
             // Compute costs to all vertices

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

@@ -39,7 +39,7 @@ public static final <T extends Comparable<T>> List<List<Vertex<T>>> getConnected
         final List<List<Vertex<T>>> list = new ArrayList<List<Vertex<T>>>();
 
         int c = 0;
-        for (Vertex<T> v : graph.getVerticies()) 
+        for (Vertex<T> v : graph.getVertices()) 
             if (map.get(v) == null)
                 visit(map, list, v, c++);
         return list;

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

@@ -31,7 +31,7 @@ public static boolean detect(Graph<Integer> graph) {
         final Set<Graph.Vertex<Integer>> visitedVerticies = new HashSet<Graph.Vertex<Integer>>();
         final Set<Graph.Edge<Integer>> visitedEdges = new HashSet<Graph.Edge<Integer>>();
 
-        final List<Graph.Vertex<Integer>> verticies = graph.getVerticies();
+        final List<Graph.Vertex<Integer>> verticies = graph.getVertices();
         if (verticies == null || verticies.size() == 0)
             return false;
 

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

@@ -43,7 +43,7 @@ public static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> graph,
             throw (new NullPointerException("Graph must be non-NULL."));
 
         // Dijkstra's algorithm only works on positive cost graphs
-        final boolean hasNegativeEdge = checkForNegativeEdges(graph.getVerticies());
+        final boolean hasNegativeEdge = checkForNegativeEdges(graph.getVertices());
         if (hasNegativeEdge)
             throw (new IllegalArgumentException("Negative cost Edges are not allowed."));
 
@@ -62,14 +62,14 @@ private static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> graph,
             throw (new NullPointerException("start must be non-NULL."));
 
         // Dijkstra's algorithm only works on positive cost graphs
-        boolean hasNegativeEdge = checkForNegativeEdges(graph.getVerticies());
+        boolean hasNegativeEdge = checkForNegativeEdges(graph.getVertices());
         if (hasNegativeEdge)
             throw (new IllegalArgumentException("Negative cost Edges are not allowed."));
 
-        for (Graph.Vertex<Integer> v : graph.getVerticies())
+        for (Graph.Vertex<Integer> v : graph.getVertices())
             paths.put(v, new ArrayList<Graph.Edge<Integer>>());
 
-        for (Graph.Vertex<Integer> v : graph.getVerticies()) {
+        for (Graph.Vertex<Integer> v : graph.getVertices()) {
             if (v.equals(start))
                 costs.put(v, new Graph.CostVertexPair<Integer>(0, v));
             else

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

@@ -22,7 +22,7 @@ public static Map<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, Integer>> ge
         if (graph == null)
             throw (new NullPointerException("Graph must be non-NULL."));
 
-        final List<Graph.Vertex<Integer>> vertices = graph.getVerticies();
+        final List<Graph.Vertex<Integer>> vertices = graph.getVertices();
 
         final int[][] sums = new int[vertices.size()][vertices.size()];
         for (int i = 0; i < sums.length; i++) {

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

@@ -28,14 +28,14 @@ public static Map<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, List<Graph.E
         final Graph.Vertex<Integer> connector = new Graph.Vertex<Integer>(Integer.MAX_VALUE);
 
         // Add the connector Vertex to all edges.
-        for (Graph.Vertex<Integer> v : graph.getVerticies()) {
-            final int indexOfV = graph.getVerticies().indexOf(v);
-            final Graph.Edge<Integer> edge = new Graph.Edge<Integer>(0, connector, graph.getVerticies().get(indexOfV));
+        for (Graph.Vertex<Integer> v : graph.getVertices()) {
+            final int indexOfV = graph.getVertices().indexOf(v);
+            final Graph.Edge<Integer> edge = new Graph.Edge<Integer>(0, connector, graph.getVertices().get(indexOfV));
             connector.addEdge(edge);
             graph.getEdges().add(edge);
         }
 
-        graph.getVerticies().add(connector);
+        graph.getVertices().add(connector);
 
         // Second, the Bellman–Ford algorithm is used, starting from the new vertex 'connector', to find for each vertex 'v'
         // the minimum weight h(v) of a path from 'connector' to 'v'. If this step detects a negative cycle, the algorithm is terminated.
@@ -61,15 +61,15 @@ public static Map<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, List<Graph.E
 
         // Finally, 'connector' is removed, and Dijkstra's algorithm is used to find the shortest paths from each node (s) to every 
         // other vertex in the re-weighted graph.
-        final int indexOfConnector = graph.getVerticies().indexOf(connector);
-        graph.getVerticies().remove(indexOfConnector);
+        final int indexOfConnector = graph.getVertices().indexOf(connector);
+        graph.getVertices().remove(indexOfConnector);
         for (Graph.Edge<Integer> e : connector.getEdges()) {
             final int indexOfConnectorEdge = graph.getEdges().indexOf(e);
             graph.getEdges().remove(indexOfConnectorEdge);
         }
 
         final Map<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, List<Graph.Edge<Integer>>>> allShortestPaths = new HashMap<Graph.Vertex<Integer>, Map<Graph.Vertex<Integer>, List<Graph.Edge<Integer>>>>();
-        for (Graph.Vertex<Integer> v : graph.getVerticies()) {
+        for (Graph.Vertex<Integer> v : graph.getVertices()) {
             final Map<Graph.Vertex<Integer>, Graph.CostPathPair<Integer>> costPaths = Dijkstra.getShortestPaths(graph, v);
             final Map<Graph.Vertex<Integer>, List<Graph.Edge<Integer>>> paths = new HashMap<Graph.Vertex<Integer>, List<Graph.Edge<Integer>>>();
             for (Graph.Vertex<Integer> v2 : costPaths.keySet()) {

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

@@ -31,7 +31,7 @@ public static Graph.CostPathPair<Integer> getMinimumSpanningTree(Graph<Integer>
         int cost = 0;
 
         final Set<Graph.Vertex<Integer>> unvisited = new HashSet<Graph.Vertex<Integer>>();
-        unvisited.addAll(graph.getVerticies());
+        unvisited.addAll(graph.getVertices());
         unvisited.remove(start); // O(1)
 
         final List<Graph.Edge<Integer>> path = new ArrayList<Graph.Edge<Integer>>();

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

@@ -40,7 +40,7 @@ public static final List<Graph.Vertex<Integer>> sort(Graph<Integer> graph) {
         edges.addAll(clone.getEdges());
 
         // Find all the vertices which have no outgoing edges
-        for (Graph.Vertex<Integer> v : clone.getVerticies()) {
+        for (Graph.Vertex<Integer> v : clone.getVertices()) {
             if (v.getEdges().size() == 0)
                 noOutgoing.add(v);
         }

src/com/jwetherell/algorithms/graph/test/Graphs.java

@@ -808,7 +808,7 @@ public void topologicalSortOnDirectedGraph() {
                 while (iter1.hasNext() && iter2.hasNext()) {
                     final Graph.Vertex<Integer> v1 = (Graph.Vertex<Integer>) iter1.next();
                     final Graph.Vertex<Integer> v2 = (Graph.Vertex<Integer>) iter2.next();
-                    assertTrue("Topological sort error. v1="+v1+" v2", v1.equals(v2));
+                    assertTrue("Topological sort error. v1="+v1+" v2="+v2, v1.equals(v2));
                 }
             }
         }