simplified DFS, topological sorting

Author: sherxon

src/algo/graph/BFS.java

@@ -13,49 +13,46 @@
  */
 public class BFS {
 
-    Map<Integer, Integer> path = new HashMap<>();
+    List<Integer> path = new LinkedList<>();
     private Graph graph;
 
+
     public BFS(Graph graph) {
         this.graph = graph;
     }
 
     public void search(Integer root) {
         if (root == null || !graph.getVertices().contains(root)) return;
+
         Set<Integer> visited = new HashSet<>();
         Queue<Integer> queue = new LinkedList<>();
+
         visited.add(root);
         queue.add(root);
-        path.put(root, null);
-        while (!queue.isEmpty()){
+
+
+        while (!queue.isEmpty()) {
+
             Integer vertex = queue.remove();
             proccessVertex(vertex);
+
             for (Integer neighbor : graph.getNeighbors(vertex))
                 if (!visited.contains(neighbor)) {
-                    path.put(neighbor, vertex);
                     visited.add(neighbor);
                     queue.add(neighbor);
                 }
         }
     }
 
     private void proccessVertex(Integer vertex) {
-        // process vertex: default not nothing;
+        path.add(vertex);
     }
 
 
-    public List<Integer> getPathFrom(Integer source, Integer sink) {
-        List<Integer> list = new ArrayList<>();
-        if (sink == null || !graph.getVertices().contains(sink))
-            return list;
-
+    public List<Integer> getPathFrom(Integer source) {
+        if (source == null || !graph.getVertices().contains(source))
+            return null;
         search(source);
-
-        Integer current = sink;
-        while (path.get(current) != null) {
-            list.add(current);
-            current = path.get(current);
-        }
-        return list;
+        return path;
     }
 }

src/algo/graph/BFSBottomUp.java

@@ -1,61 +1,68 @@
 package algo.graph;
 
 import ds.graph.Graph;
-import ds.graph.Vertex;
 
-import java.util.Stack;
+import java.util.*;
 
 /**
  * Created by sherxon on 1/4/17.
  */
-public class DFS<T> {
-    Graph<T, Number> graph;
+public class DFS {
+    protected Graph graph;
+    Set<Integer> visited;
+    List<Integer> path;
 
-    public DFS(Graph<T, Number> graph) {
+    public DFS(Graph graph) {
         this.graph = graph;
+        visited = new HashSet<>();
+        path = new LinkedList<>();
     }
 
-    public void search(T source) {
-        Vertex<T> vertex= graph.getVertex(source);
-        vertex.setVisited(true);
-        for (Vertex<T> tVertex : vertex.getNeighbors())
-            if(!tVertex.isVisited()){
-                tVertex.setParent(vertex);
-                search(tVertex.getValue());
+    public void search(Integer source) {
+
+        visited.add(source);
+        processVertex(source);
+
+        for (Integer neighbor : graph.getNeighbors(source))
+            if (!visited.contains(neighbor)) {
+                search(neighbor);
             }
     }
-    public void searchIterative(T source) {
-        Vertex<T> vertex= graph.getVertex(source);
-        Stack<Vertex<T>> stack= new Stack<>();
-        stack.add(vertex);
+
+    public void processVertex(Integer source) {
+        path.add(source);
+    }
+
+    public void searchIterative(Integer source) {
+        if (source == null || !graph.getVertices().contains(source)) return;
+
+        visited.clear();
+        path.clear();
+
+        Stack<Integer> stack = new Stack<>();
+        stack.add(source);
+
         while (!stack.isEmpty()){
-            Vertex<T> v=stack.pop();
-            v.setVisited(true);
-            for (Vertex<T> tVertex : v.getNeighbors()) {
-                if(!tVertex.isVisited()){
-                    tVertex.setParent(v);
-                    stack.add(tVertex);
-                }
+            Integer v = stack.pop();
+
+            visited.add(v);
+            processVertex(v);
+
+            for (Integer neighbor : graph.getNeighbors(v)) {
+                if (!visited.contains(neighbor))
+                    stack.add(neighbor);
             }
         }
 
     }
 
 
-    private  void clearGraph() {
-        for (Vertex<T> vertex : graph.getVertices()) {
-            vertex.setVisited(false);
-            vertex.setParent(null);
-        }
-    }
-    public void printPathFrom(T t){
-        Vertex<T> root=graph.getVertex(t);
-        if(root==null)return;
-        while (root.getParent()!=null){
-            System.out.print(root.getValue() + " -> ");
-            root=root.getParent();
-        }
-        System.out.println("a");
+    public List<Integer> getPathFrom(Integer source) {
+
+        if (source == null || !graph.getVertices().contains(source))
+            return null;
+        search(source);
+        return path;
     }
 
 

src/algo/graph/DFS.java

@@ -1,50 +1,46 @@
 package algo.graph;
 
 import ds.graph.Graph;
-import ds.graph.Vertex;
 
+import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
-import java.util.Stack;
 
 /**
  * Created by sherxon on 1/4/17.
  */
-public class TopologicalSorting<T> {
-    private Graph<T, Number> graph;
+public class TopologicalSorting extends DFS {
+    List<Integer> list;
 
-    public TopologicalSorting(Graph<T, Number> graph) {
-        this.graph = graph;
+    public TopologicalSorting(Graph graph) {
+        super(graph);
+        list = new ArrayList<>();
     }
 
     // this works with DAG Only
     // first we will choose any vertex who that does not have incoming edges (sources)
     // sources can be found easier if incoming edge count is recorded in each vertex
-    List<T> topSort(){
-        Stack<T> stack=new Stack<>();//stack is also good option
-        Set<Vertex<T>> sources=new HashSet<>();
-        for (Vertex<T> vertex : graph.getVertices())
+    List<Integer> topSort() {
+
+        Set<Integer> sources = new HashSet<>();
+        for (Integer vertex : graph.getVertices())
             sources.add(vertex);
 
-        for (Vertex<T> vertex : graph.getVertices())
-            for (Vertex<T> tVertex : vertex.getNeighbors())
+        for (Integer vertex : graph.getVertices())
+            for (Integer tVertex : graph.getNeighbors(vertex))
                 sources.remove(tVertex);
 
-        for (Vertex<T> source : sources)
-            if(!source.isVisited())
-                dfs(source, stack);
+        for (Integer source : sources)
+            if (!visited.contains(source))
+                search(source);
 
-        return stack;
+        return list;
     }
 
-    private void dfs(Vertex<T> source, List<T> list) {
-        source.setVisited(true);
-        for (Vertex<T> vertex : source.getNeighbors()) {
-            if(!vertex.isVisited()){
-                dfs(vertex, list);
-            }
-        }
-        list.add(source.getValue());
+    @Override
+    public void processVertex(Integer source) {
+        super.processVertex(source);
+        list.add(source);
     }
 }

src/algo/graph/Test.java

@@ -24,6 +24,11 @@ public Set<Integer> getVertices() {
         return new HashSet<>(vertexMap.keySet());
     }
 
+    @Override
+    public Set<Integer> getNeighbors(Integer ver) {
+        return vertexMap.get(ver);
+    }
+
 
     @Override
     public Double addEdge(Integer v1, Integer v2) {