BFS in graph: done

Author: rampatra

Diff for: src/main/java/com/ctci/treesandgraphs/GraphNode.java

@@ -1,8 +1,17 @@
 package com.ctci.treesandgraphs;
 
+import java.util.HashSet;
+import java.util.Set;
+
 /**
  * @author rampatra
  * @since 2019-03-21
  */
 public class GraphNode {
-}
+    int value;
+    Set<GraphNode> adjacent = new HashSet<>();
+    
+    GraphNode(int value) {
+        this.value = value;
+    }
+}

Diff for: src/main/java/com/ctci/treesandgraphs/RouteBetweenNodes.java

@@ -1,8 +1,87 @@
 package com.ctci.treesandgraphs;
 
+import java.util.ArrayDeque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
 /**
  * @author rampatra
  * @since 2019-03-21
  */
 public class RouteBetweenNodes {
+
+    public static void main(String[] args) {
+        Graph g = new Graph();
+        g.addEdge(1, 2);
+        g.addEdge(2, 3);
+        g.addEdge(4, 5);
+        g.addEdge(5, 6);
+        System.out.println("Route exists from 1 to 2: " + g.isRoutePresent(1, 2));
+        System.out.println("Route exists from 2 to 5: " + g.isRoutePresent(2, 5));
+        System.out.println("Route exists from 1 to 3: " + g.isRoutePresent(1, 3));
+        System.out.println("Route exists from 4 to 6: " + g.isRoutePresent(4, 6));
+        System.out.println("Route exists from 6 to 4: " + g.isRoutePresent(6, 4));
+        System.out.println("Route exists from 6 to 5: " + g.isRoutePresent(6, 5));
+    }
+}
+
+class Graph {
+
+    private static final Map<Integer, GraphNode> nodes = new HashMap<>();
+
+    void addEdge(int v1, int v2) {
+        GraphNode n1 = nodes.get(v1);
+        GraphNode n2 = nodes.get(v2);
+
+        if (n1 == null) {
+            n1 = new GraphNode(v1);
+            nodes.put(v1, n1);
+        }
+        if (n2 == null) {
+            n2 = new GraphNode(v2);
+            nodes.put(v2, n2);
+        }
+
+        n1.adjacent.add(n2); // as it is a directed graph
+    }
+
+    /**
+     * Checks for a path from a node with value {@code v1} to another node with value {@code v2} in a breadth-first
+     * manner.
+     *
+     * @param v1 the value of the first node or starting node.
+     * @param v2 the value of the ending node.
+     * @return {@code true} if path exists, {@code false} otherwise.
+     */
+    boolean isRoutePresent(int v1, int v2) {
+        Queue<GraphNode> queue = new ArrayDeque<>();
+        Set<GraphNode> visited = new HashSet<>();
+
+        GraphNode n1 = nodes.get(v1);
+        GraphNode n2 = nodes.get(v2);
+
+        if (n1 == null || n2 == null) {
+            return false;
+        }
+
+        queue.add(n1);
+
+        while (!queue.isEmpty()) {
+            GraphNode n = queue.poll();
+
+            if (visited.contains(n)) {
+                continue;
+            }
+            if (n.adjacent.contains(n2)) {
+                return true;
+            }
+            queue.addAll(n.adjacent);
+            visited.add(n);
+        }
+
+        return false;
+    }
 }

Diff for: src/main/java/com/rampatra/base/UndirectedGraph.java

@@ -18,8 +18,9 @@ public class UndirectedGraph<E extends Comparable<E>> extends Graph<E> {
     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.
+     * Adds an edge between a node with value {@code value} and another node with value {@code adjacentValue}. As the
+     * graph is undirected, the edges are added in both the nodes. If nodes with respective values are not present in
+     * the graph then this method creates the nodes.
      *
      * @param value         refers to the value for first node
      * @param adjacentValue refers to the value for the second node
@@ -143,7 +144,7 @@ public static void main(String[] args) {
         graph.print();
 
         System.out.println("----");
-        
+
         // has path DFS
         System.out.println(graph.hasPathDFS(1, 5));
         System.out.println(graph.hasPathDFS(1, 6));

Diff for: src/main/java/com/rampatra/bits/README.md

@@ -2,7 +2,7 @@
 
 ### Basic Operators
 
-#### AND:   
+#### AND:
 
 | x | y | x `&` y |
 ----|---|:-------:|
@@ -63,4 +63,25 @@ _Disclaimer: We are taking `byte` (8 bits) as our datatype to explain the
 
 -64 >>> 2 = 56
 
-> 111000000 >>> 2 = 00111000
+> 111000000 >>> 2 = 00111000
+
+### Helpful Masks
+
+#### 1. Set the 4th bit from right:
+
+```java
+int mask = 1 << 3;
+```
+
+For example, 
+
+```
+00100000 | mask = 00101000
+```
+    
+#### 2. Set the first 3 bits from right:
+
+```java
+int mask = (1 << 4) - 1;
+```
+

Diff for: src/main/java/com/rampatra/blockchain/MessageHandler.java

@@ -33,12 +33,17 @@ public void run() {
             while ((message = (Message) in.readObject()) != null) {
                 handleMessage(message);
             }
-            in.close();
-            out.close();
         } catch (Exception e) {
             if (!(e instanceof SocketException)) {
                 throw new RuntimeException(e);
             }
+        } finally {
+            try {
+                in.close();
+                out.close();
+            } catch (Exception e) {
+                // do nothing
+            }
         }
     }