Directed graph implementations

Author: nbaruah

src/main/java/graph/undirected/Graph.java renamed to src/main/java/graph/common/Graph.java

@@ -1,4 +1,4 @@
-package graph.undirected;
+package graph.common;
 
 /**
  * Created by nbaruah on 11/12/2016.

src/main/java/graph/directed/DiGraph.java

@@ -0,0 +1,10 @@
+package graph.directed;
+
+import graph.common.Graph;
+
+/**
+ * Created by nbaruah on 11/16/2016.
+ */
+public interface DiGraph extends Graph {
+    DiGraph reverse();
+}

src/main/java/graph/directed/DirectedGraph.java

@@ -0,0 +1,92 @@
+package graph.directed;
+
+import java.util.LinkedList;
+
+/**
+ * Created by nbaruah on 11/18/2016.
+ */
+public class DirectedGraph implements DiGraph {
+    LinkedList<Integer>[] adjList;
+    int V;
+    int E;
+
+    /**
+     * Create an empty digraph with V vertices
+     * @param v the number of vertices
+     */
+    public DirectedGraph(int v){
+        this.V = v;
+        this.E = 0;
+        adjList = new LinkedList[v];
+        for (int i = 0; i < v; i++) {
+            adjList[i] = new LinkedList<Integer>();
+        }
+    }
+
+    /**
+     * Reverse of this digraph
+     * @return reverse directed graph of this graph,
+     * where every edge V-->W will be W-->V
+     */
+    public DiGraph reverse() {
+        DiGraph reverseG = new DirectedGraph(this.V);
+        for (int v = 0; v < this.V; v++) {
+            for (int adjV : this.adjList[v]){
+                reverseG.addEdge(adjV, v);
+            }
+        }
+        return reverseG;
+    }
+
+    public int V() {
+        return V;
+    }
+
+    public int E() {
+        return E;
+    }
+
+    public void addEdge(int v, int w) {
+        adjList[v].add(w);
+        E++;
+    }
+
+    public Iterable<Integer> getAdjVertices(int v) {
+        return adjList[v];
+    }
+
+    public int getDegree(int v) {
+        return adjList[v].size();
+    }
+
+    public String toString(){
+        StringBuilder builder = new StringBuilder();
+        builder.append("V = " + this.V + "\t E = " + this.E + "\n");
+        for (int v = 0; v < this.V; v++) {
+            builder.append(v + " -> ");
+            for (int adjV : adjList[v]){
+                builder.append(adjV + ", ");
+            }
+            builder.append("\n");
+        }
+        return builder.toString();
+    }
+
+    public static void main(String[] args){
+        DiGraph G = new DirectedGraph(6);
+        G.addEdge(0, 1);
+        G.addEdge(0, 5);
+        G.addEdge(2, 0);
+        G.addEdge(2, 3);
+        G.addEdge(3, 2);
+        G.addEdge(3, 5);
+        G.addEdge(4, 2);
+        G.addEdge(4, 3);
+        G.addEdge(5, 4);
+
+        System.out.println(G);
+        System.out.println(G.reverse());
+        System.out.println(G.getDegree(4));
+        System.out.println(G.getAdjVertices(4));
+    }
+}

src/main/java/graph/undirected/AdjacencyList.java

@@ -1,5 +1,7 @@
 package graph.undirected;
 
+import graph.common.Graph;
+
 import java.util.LinkedList;
 
 /**

src/main/java/graph/undirected/BFSPaths.java

@@ -1,6 +1,7 @@
 package graph.undirected;
 
 import common.Queue;
+import graph.common.Graph;
 
 import java.util.Stack;
 

src/main/java/graph/undirected/ConnComponents.java

@@ -0,0 +1,75 @@
+package graph.undirected;
+
+import graph.common.Graph;
+
+import java.util.Stack;
+
+/**
+ * Created by nbaruah on 11/16/2016.
+ */
+public class ConnComponents {
+    private boolean[] visited; // visited[v] indicates that vertex v is visited
+    private int[] id; //
+    private int[] edgeTo;
+    private int count;
+
+    public ConnComponents(Graph G){
+        visited = new boolean[G.V()];
+        id = new int[G.V()];
+        edgeTo = new int[G.V()];
+        for (int v = 0; v < G.V(); v++) {
+            if (!visited[v]){
+                dfs(G, v);
+                count++;
+                edgeTo[v] = -1;
+            }
+        }
+    }
+
+    public boolean isConnected(int v, int w){
+        return id[v] == id[w];
+    }
+
+    public int count(){
+        return count;
+    }
+
+    public int id(int v){
+        return id[v];
+    }
+
+    private void dfs(Graph G, int v){
+        visited[v] = true;
+        id[v] = count;
+        for (int adjVertex : G.getAdjVertices(v)){
+            if (!visited[adjVertex]){
+                dfs(G, adjVertex);
+                edgeTo[adjVertex] = v;
+            }
+        }
+    }
+
+    public  Iterable<Integer> getPathTo(int v){
+        Stack<Integer> path = new Stack<Integer>();
+        for (int currentV = v; currentV != -1 ; currentV = edgeTo[currentV]) {
+            path.push(currentV);
+        }
+        return path;
+    }
+
+    public static void main(String[] args){
+        Graph g = new AdjacencyList(6);
+        g.addEdge(0,1);
+        g.addEdge(0,2);
+        g.addEdge(0,3);
+        g.addEdge(2,3);
+        g.addEdge(4,5);
+
+        ConnComponents cc = new ConnComponents(g);
+        System.out.println("Number of connected components: " + cc.count());
+        System.out.println("Is 4 and 3 connected: " + cc.isConnected(4, 3));
+        System.out.println("Is 0 and 3 connected: " + cc.isConnected(0, 3));
+        System.out.println("Path to 3: " + cc.getPathTo(3));
+        System.out.println("Path to 5: " + cc.getPathTo(6));
+    }
+}

src/main/java/graph/undirected/DFSPaths.java

@@ -1,5 +1,7 @@
 package graph.undirected;
 
+import graph.common.Graph;
+
 import java.util.Stack;
 
 /**
@@ -10,9 +12,9 @@
  */
 public class DFSPaths implements Paths{
     private boolean[] visited; // vertex indexed array to mark when a vertex is visited
-    private int[] visitedFrom; // vertex indexed array to track back from which vertex we reached a particular vertex for the first time
-    private int source; // Stores the source vertex
-    private int sizeOfG; // Stores the number of vertices in the graph to be processed
+    private int[] edgeTo; // vertex indexed array to track back from which vertex we reached a particular vertex for the first time
+    private int source; // source vertex
+    private int sizeOfG; // number of vertices in the graph
 
     /**
      * Find paths in G from source vertex
@@ -24,7 +26,7 @@ public DFSPaths(Graph G, int source){
         validateVertex(source);
         this.source = source;
         visited = new boolean[G.V()];
-        visitedFrom = new int[G.V()];
+        edgeTo = new int[G.V()];
         dfs(G, source);
     }
 
@@ -52,23 +54,23 @@ public Iterable<Integer> pathTo(int v){
         int currentVertex = v;
         while (currentVertex != this.source){
             path.push(currentVertex);
-            currentVertex = visitedFrom[currentVertex];
+            currentVertex = edgeTo[currentVertex];
         }
         path.push(this.source);
         return path;
     }
 
     /**
-     * Performs a DFS from source, to visit each vertex that has a path with source (undirected graph)
-     * @param G
-     * @param source
+     * Performs a DFS from v, to visit each vertex that has a path with v (undirected graph)
+     * @param G the graph on which DFS is to perform
+     * @param v the vertex from which dfs is performed
      */
-    private void dfs(Graph G, int source){
-        visited[source] = true;
-        for (int adjV : G.getAdjVertices(source)){
+    private void dfs(Graph G, int v){
+        visited[v] = true;
+        for (int adjV : G.getAdjVertices(v)){
             if (!visited[adjV]){
                 dfs(G, adjV);
-                visitedFrom[adjV] = source;
+                edgeTo[adjV] = v;
             }
         }
     }
@@ -87,11 +89,6 @@ public static void main(String[] args){
         G.addEdge(3, 4);
 
         DFSPaths DFSPathsFrom_0 = new DFSPaths(G, 0);
-        for (int v : DFSPathsFrom_0.pathTo(2)){
-            System.out.print(" => " +v);
-        }
-        System.out.println();
-
-        System.out.println(DFSPathsFrom_0.hasPathTo(2));
+        System.out.println(DFSPathsFrom_0.pathTo(3));
     }
 }

src/main/java/graph/undirected/GraphClient.java

@@ -0,0 +1,31 @@
+package graph.undirected;
+
+import graph.common.Graph;
+
+/**
+ * Created by nbaruah on 11/15/2016.
+ */
+public class GraphUtility {
+    public static int degree(Graph G, int v){
+        if (v < 0 || v >= G.V()){
+            throw new ArrayIndexOutOfBoundsException("Vertex: " + v + " is not in between 0 and " + (G.V() - 1));
+        }
+        int degree = 0;
+        for (int vertex : G.getAdjVertices(v)) {
+            degree ++;
+        }
+        return degree;
+    }
+
+    public static int maxDegree(Graph G){
+        return 0;
+    }
+
+    public static int avgDegree(Graph G){
+        return 0;
+    }
+
+    public static int numOfSelfLoops(Graph G){
+        return 0;
+    }
+}