Merge branch 'jsroyal-master' - Graph.DFS

Author: Justin Wetherell

README.md

@@ -128,6 +128,8 @@ This is a collection of algorithms and data structures which I've implement over
 * A* path finding algorithm
 * Maximum flow
   - Push-Relabel
+* Graph Traversal
+  - Depth First Traversal  
 
 ## Search
 * Get index of value in array

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

@@ -21,40 +21,40 @@ private CycleDetection() { }
      * @param graph Graph
      * @return true if a cycle exists
      */
-    public static boolean detect(Graph<Integer> graph) {
+    public static <T extends Comparable<T>> boolean detect(Graph<T> graph) {
         if (graph == null)
             throw new IllegalArgumentException("Graph is NULL.");
 
         if (graph.getType() != Graph.TYPE.UNDIRECTED)
             throw new IllegalArgumentException("Graph is needs to be Undirected.");
 
-        final Set<Graph.Vertex<Integer>> visitedVerticies = new HashSet<Graph.Vertex<Integer>>();
-        final Set<Graph.Edge<Integer>> visitedEdges = new HashSet<Graph.Edge<Integer>>();
+        final Set<Graph.Vertex<T>> visitedVerticies = new HashSet<Graph.Vertex<T>>();
+        final Set<Graph.Edge<T>> visitedEdges = new HashSet<Graph.Edge<T>>();
 
-        final List<Graph.Vertex<Integer>> verticies = graph.getVertices();
+        final List<Graph.Vertex<T>> verticies = graph.getVertices();
         if (verticies == null || verticies.size() == 0)
             return false;
 
         // Select the zero-ith element as the root
-        final Graph.Vertex<Integer> root = verticies.get(0);
+        final Graph.Vertex<T> root = verticies.get(0);
         return depthFirstSearch(root, visitedVerticies, visitedEdges);
     }
 
-    private static final boolean depthFirstSearch(Graph.Vertex<Integer> vertex, Set<Graph.Vertex<Integer>> visitedVerticies, Set<Graph.Edge<Integer>> visitedEdges) {
+    private static final <T extends Comparable<T>> boolean depthFirstSearch(Graph.Vertex<T> vertex, Set<Graph.Vertex<T>> visitedVerticies, Set<Graph.Edge<T>> visitedEdges) {
         if (!visitedVerticies.contains(vertex)) {
             // Found an unvisited, add to the set
             visitedVerticies.add(vertex);
 
-            final List<Graph.Edge<Integer>> edges = vertex.getEdges();
+            final List<Graph.Edge<T>> edges = vertex.getEdges();
             if (edges != null) {
                 // Follow each unvisited edge, visit the vertex the edge connects to.
-                for (Graph.Edge<Integer> edge : edges) {
-                    final Graph.Vertex<Integer> to = edge.getToVertex();
+                for (Graph.Edge<T> edge : edges) {
+                    final Graph.Vertex<T> to = edge.getToVertex();
                     boolean result = false;
                     if (to != null && !visitedEdges.contains(edge)) {
                         visitedEdges.add(edge);
 
-                        final Graph.Edge<Integer> recip = new Graph.Edge<Integer>(edge.getCost(), edge.getToVertex(), edge.getFromVertex());
+                        final Graph.Edge<T> recip = new Graph.Edge<T>(edge.getCost(), edge.getToVertex(), edge.getFromVertex());
                         visitedEdges.add(recip);
 
                         result = depthFirstSearch(to, visitedVerticies, visitedEdges);

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

@@ -0,0 +1,82 @@
+package com.jwetherell.algorithms.graph;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+
+import com.jwetherell.algorithms.data_structures.Graph;
+import com.jwetherell.algorithms.data_structures.Graph.Edge;
+import com.jwetherell.algorithms.data_structures.Graph.Vertex;
+
+/* Depth First Travesal in given "Directed graph" (Adjacany matrix) */
+public class DepthFirstTraversal {
+
+    @SuppressWarnings("unchecked")
+    public static final <T extends Comparable<T>> Graph.Vertex<T>[] depthFirstTraversal(Graph<T> graph, Graph.Vertex<T> source) {
+        // use for look-up via index
+        final ArrayList<Vertex<T>> vertices = new ArrayList<Vertex<T>>();
+        vertices.addAll(graph.getVertices());
+
+        // used for look-up via vertex
+        final int n = vertices.size();
+        final Map<Vertex<T>,Integer> vertexToIndex = new HashMap<Vertex<T>,Integer>();
+        for (int i=0; i<n; i++) {
+            final Vertex<T> v = vertices.get(i);
+            vertexToIndex.put(v,i);
+        }
+
+        // adjacency matrix
+        final byte[][] adj = new byte[n][n];
+        for (int i=0; i<n; i++) {
+            final Vertex<T> v = vertices.get(i);
+            final int idx = vertexToIndex.get(v);
+            final byte[] array = new byte[n];
+            adj[idx] = array;
+            final List<Edge<T>> edges = v.getEdges();
+            for (Edge<T> e : edges)
+                array[vertexToIndex.get(e.getToVertex())] = 1;
+        }
+
+        // visited array
+        final byte[] visited = new byte[n];
+        for (int i = 0; i < visited.length; i++)
+            visited[i] = -1;
+
+        // for holding results
+        final Graph.Vertex<T>[] arr = new Graph.Vertex[n];
+
+        // start at the source
+        Vertex<T> element = source;
+        int c = 0;
+        int i = vertexToIndex.get(element);
+        visited[i] = 1;   
+        int k = 0;
+        arr[k] = element;
+        k++;
+
+        final Stack<Vertex<T>> stack = new Stack<Vertex<T>>();
+        stack.push(source);
+        while (!stack.isEmpty()) {    
+            element = stack.peek();
+            c = vertexToIndex.get(element);
+            i = 0;    
+            while (i < n) {
+                if (adj[c][i] == 1 && visited[i] == -1) {
+                    stack.push(element);
+                    visited[i] = 1;
+                    element = vertices.get(i);
+                    arr[k] = element;
+                    k++;
+                    c = vertexToIndex.get(element);
+                    i = 0;
+                    continue;
+                }
+                i++;
+            }
+            stack.pop();    
+        }
+        return arr;
+    }
+}

test/com/jwetherell/algorithms/graph/test/DepthFirstTraversalTest.java

@@ -0,0 +1,56 @@
+package com.jwetherell.algorithms.graph.test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+
+import com.jwetherell.algorithms.data_structures.Graph;
+import com.jwetherell.algorithms.graph.DepthFirstTraversal;
+
+public class DepthFirstTraversalTest {
+
+    private static final List<Graph.Vertex<Integer>>    vertices    = new ArrayList<Graph.Vertex<Integer>>();
+    private static final List<Graph.Edge<Integer>>      edges       = new ArrayList<Graph.Edge<Integer>>();
+
+    private static final Graph.Vertex<Integer>          v0          = new Graph.Vertex<Integer>(0);
+    private static final Graph.Vertex<Integer>          v1          = new Graph.Vertex<Integer>(1);
+    private static final Graph.Vertex<Integer>          v2          = new Graph.Vertex<Integer>(2);
+    private static final Graph.Vertex<Integer>          v3          = new Graph.Vertex<Integer>(3);
+
+    static {
+        vertices.add(v0);
+        vertices.add(v1);
+        vertices.add(v2);
+        vertices.add(v3);
+
+        edges.add(new Graph.Edge<Integer>(0, v0, v1));
+        edges.add(new Graph.Edge<Integer>(0, v0, v2));
+        edges.add(new Graph.Edge<Integer>(0, v1, v2));
+        edges.add(new Graph.Edge<Integer>(0, v2, v0));
+        edges.add(new Graph.Edge<Integer>(0, v2, v3));
+        edges.add(new Graph.Edge<Integer>(0, v3, v3));
+    }
+
+    private static final Graph<Integer>                 graph       = new Graph<Integer>(Graph.TYPE.DIRECTED, vertices, edges);
+
+    @Test
+    public void test1() {
+        final Graph.Vertex<Integer>[] result = DepthFirstTraversal.depthFirstTraversal(graph, v2);
+        Assert.assertTrue(result[0].getValue()==2);
+        Assert.assertTrue(result[1].getValue()==0);
+        Assert.assertTrue(result[2].getValue()==1);
+        Assert.assertTrue(result[3].getValue()==3);
+    }
+
+    @Test
+    public void test2() {
+        final Graph.Vertex<Integer>[] result = DepthFirstTraversal.depthFirstTraversal(graph, v0);
+        Assert.assertTrue(result[0].getValue()==0);
+        Assert.assertTrue(result[1].getValue()==1);
+        Assert.assertTrue(result[2].getValue()==2);
+        Assert.assertTrue(result[3].getValue()==3);
+    }
+}