Graph DFS and BFS: done

Author: rampatra

src/main/java/com/rampatra/common/UndirectedGraph.java

@@ -1,10 +1,13 @@
 package com.rampatra.common;
 
+import java.util.ArrayDeque;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Queue;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  * @author rampatra
@@ -14,32 +17,47 @@ public class UndirectedGraph<E extends Comparable<E>> extends Graph<E> {
     // map for a fast lookup
     private Map<E, GraphNode<E>> nodes = new HashMap<>();
 
+    /**
+     * Adds an edge between a node with value {@code value} and another node with value {@code adjacentValue}.
+     * If nodes with respective values are not present in the graph then this method creates them.
+     *
+     * @param value         refers to the value for first node
+     * @param adjacentValue refers to the value for the second node
+     * @return the node with value {@code value}, or the first node
+     */
     public GraphNode<E> addEdge(E value, E adjacentValue) {
         GraphNode<E> node = nodes.get(value);
         GraphNode<E> adjNode = nodes.get(adjacentValue);
-        if (node == null) {
+        if (node == null && value != null) {
             node = new GraphNode<>(value);
             nodes.put(value, node);
         }
-        if (adjNode == null) {
+        if (adjNode == null && adjacentValue != null) {
             adjNode = new GraphNode<>(adjacentValue);
             nodes.put(adjacentValue, adjNode);
         }
-        node.adjacentNodes.add(adjNode);
-        adjNode.adjacentNodes.add(node); // as this is an undirected graph
+        if (node != null && adjNode != null) {
+            node.adjacentNodes.add(adjNode);
+            adjNode.adjacentNodes.add(node); // as this is an undirected graph
+        }
         return node;
     }
 
-    // todo
+    /**
+     * Method to check whether {@code src} and {@code dest} nodes are connected by depth first search (DFS).
+     *
+     * @param src  source node in graph
+     * @param dest destination node in graph
+     * @return {@code true} if there is a path from {@code src} to {@code dest}, {@code false} otherwise
+     */
     public boolean hasPathDFS(E src, E dest) {
         GraphNode<E> s = nodes.get(src);
         GraphNode<E> d = nodes.get(dest);
-        Set<GraphNode<E>> visited = new HashSet<>();
+        Set<GraphNode<E>> visited = new HashSet<>(); // to save all visited nodes so that we do not visit them again
         return hasPathDFS(s, d, visited);
     }
 
-    // todo
-    public boolean hasPathDFS(GraphNode<E> src, GraphNode<E> dest, Set<GraphNode<E>> visited) {
+    private boolean hasPathDFS(GraphNode<E> src, GraphNode<E> dest, Set<GraphNode<E>> visited) {
         if (src == null || dest == null) {
             return false;
         }
@@ -56,6 +74,45 @@ public boolean hasPathDFS(GraphNode<E> src, GraphNode<E> dest, Set<GraphNode<E>>
         return false;
     }
 
+    /**
+     * Method to check whether {@code src} and {@code dest} nodes are connected by breadth first search (BFS).
+     *
+     * @param src  source node in graph
+     * @param dest destination node in graph
+     * @return {@code true} if there is a path from {@code src} to {@code dest}, {@code false} otherwise
+     */
+    public boolean hasPathBFS(E src, E dest) {
+        GraphNode<E> s = nodes.get(src);
+        GraphNode<E> d = nodes.get(dest);
+        if (s == null || d == null) {
+            return false;
+        }
+        Set<GraphNode<E>> visited = new HashSet<>();
+        Queue<GraphNode<E>> toVisit = new ArrayDeque<>();
+        toVisit.add(s);
+        return hasPathBFS(d, visited, toVisit);
+    }
+
+    private boolean hasPathBFS(GraphNode<E> dest, Set<GraphNode<E>> visited, Queue<GraphNode<E>> toVisit) {
+        while (!toVisit.isEmpty()) {
+            GraphNode<E> node = toVisit.poll();
+            if (visited.contains(node)) {
+                continue;
+            } else {
+                visited.add(node);
+            }
+            toVisit.addAll(node.adjacentNodes.stream().filter(n -> !visited.contains(n)).collect(Collectors.toList()));
+            if (node.value.compareTo(dest.value) == 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    /**
+     * Prints the node values in the graph.
+     */
     public void print() {
         Set<E> visited = new HashSet<>();
         System.out.print("[");
@@ -82,12 +139,27 @@ public static void main(String[] args) {
         graph.addEdge(5, 1);
         graph.addEdge(5, 6);
         graph.addEdge(8, null);
+        graph.addEdge(null, 9);
         graph.print();
-        // todo
+
+        System.out.println("----");
+        
+        // has path DFS
         System.out.println(graph.hasPathDFS(1, 5));
         System.out.println(graph.hasPathDFS(1, 6));
         System.out.println(graph.hasPathDFS(1, 8));
         System.out.println(graph.hasPathDFS(4, 8));
+        System.out.println(graph.hasPathDFS(4, 9));
         System.out.println(graph.hasPathDFS(4, 100));
+
+        System.out.println("----");
+
+        // has path BFS
+        System.out.println(graph.hasPathBFS(1, 5));
+        System.out.println(graph.hasPathBFS(1, 6));
+        System.out.println(graph.hasPathBFS(1, 8));
+        System.out.println(graph.hasPathBFS(4, 8));
+        System.out.println(graph.hasPathBFS(4, 9));
+        System.out.println(graph.hasPathBFS(4, 100));
     }
 }