added grid bfs, fixed java dfs

Author: Morfly

src/java/sequential/graph/bfs/BUILD

@@ -2,4 +2,10 @@ java_binary(
     name = "bfs",
     main_class = "sequential.graph.bfs.BreadthFirstTraversal",
     srcs = glob(["*.java"]),
+)
+
+java_binary(
+    name = "bfs_grid",
+    main_class = "sequential.graph.bfs.GridBreadthFirstTraversal",
+    srcs = glob(["*.java"]),
 )

src/java/sequential/graph/bfs/GridBreadthFirstTraversal.java

@@ -0,0 +1,85 @@
+package sequential.graph.bfs;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+
+
+public class GridBreadthFirstTraversal {
+
+    private final static int[] ROW_DIRECTIONS = {0, -1, 0, 1};
+    private final static int[] COL_DIRECTIONS = {-1, 0, 1, 0};
+
+    private static class Vertex {
+        final int row, col;
+
+        public Vertex(int row, int col) {
+            this.row = row;
+            this.col = col;
+        }
+    }
+
+
+    public static <T> Collection<T> bfs(T[][] graph, int rootRow, int rootCol) {
+        if (!isGraphValid(graph, rootRow, rootCol)) throw new IllegalArgumentException("Invalid graph.");
+
+        int rows = graph.length;
+        int cols = graph[0].length;
+
+        var explored = new boolean[rows][cols];
+        var traversed = new ArrayList<T>();
+        var searchQueue = new ArrayDeque<Vertex>();
+
+        searchQueue.add(new Vertex(rootRow, rootCol));
+        while (!searchQueue.isEmpty()) {
+            var vertex = searchQueue.removeFirst();
+            int row = vertex.row;
+            int col = vertex.col;
+
+            if (!explored[row][col] && graph[row][col] != null) {
+                explored[row][col] = true;
+                traversed.add(graph[row][col]);
+
+                for (int i = 0; i < 4; i++) {
+                    int nextRow = row + ROW_DIRECTIONS[i];
+                    int nextCol = col + COL_DIRECTIONS[i];
+
+                    if (nextRow >= 0 && nextRow < rows && nextCol >= 0 && nextCol < cols) {
+                        searchQueue.add(new Vertex(nextRow, nextCol));
+                    }
+                }
+            }
+        }
+        return traversed;
+    }
+
+    private static <T> boolean isGraphValid(T[][] graph, int rootRow, int rootCol) {
+        // check if graph is not empty.
+        if (graph.length == 0 || graph[0].length == 0) return false;
+
+        int rows = graph.length;
+        int cols = graph[0].length;
+
+        // check if root vertex is valid.
+        if (rootRow < 0 || rootRow >= rows || rootCol < 0 || rootCol >= cols) return false;
+
+        // check if graph dimensions are valid.
+        for (var row : graph)
+            if (row.length != cols) return false;
+
+        return true;
+    }
+
+
+    public static void main(String[] args) {
+        Integer[][] graph = {
+                {3, 2, 1},
+                {1, 4, 4},
+                {9, 3, null}
+        };
+
+        System.out.println(
+                bfs(graph, 0, 0)
+        );
+    }
+}

src/java/sequential/graph/dfs/RecursiveDepthFirstTraversal.java

@@ -7,34 +7,24 @@
 import java.util.Set;
 
 
-class RecursiveDepthFirstTraversal<T> {
+class RecursiveDepthFirstTraversal {
 
-    private Map<T, List<T>> graph;
-    private Set<T> explored;
 
-    public synchronized Collection<T> dfs(Map<T, List<T>> graph, T root) {
-        this.graph = graph;
-        explored = new LinkedHashSet<>();
+    public static <T> Collection<T> dfs(Map<T, List<T>> graph, T root) { 
+        var explored = new LinkedHashSet<T>();       
 
-        var traversed = explore(root);
+        explore(root, graph, explored);
 
-        clear();
-        return traversed;
+        return explored;
     }
 
-    private Collection<T> explore(T node) {
+    private static <T> void explore(T node, Map<T, List<T>> graph, Set<T> explored) {
         explored.add(node);
 
         var successors = graph.getOrDefault(node, List.of());
-        for (var succ : successors)
-            if (!explored.contains(succ)) explore(succ);
-        
-        return explored;
-    }
-
-    private void clear() {
-        explored = null;
-        graph = null;
+        for (var succ : successors) {
+            if (!explored.contains(succ)) explore(succ, graph, explored);
+        }
     }
 
 
@@ -47,7 +37,7 @@ public static void main(String[] args) {
         );
 
         System.out.println(
-            new RecursiveDepthFirstTraversal().dfs(graph, "you")
+            dfs(graph, "you")
         );
     }
 }

src/kotlin/sequential/graph/bfs/BUILD

@@ -9,4 +9,10 @@ java_binary(
     name = "bfs",
     main_class = "sequential.graph.bfs.BreadthFirstTraversalKt",
     runtime_deps = [":bfs_lib"],
+)
+
+java_binary(
+    name = "bfs_grid",
+    main_class = "sequential.graph.bfs.grid.GridBreadthFirstTraversalKt",
+    runtime_deps = [":bfs_lib"],
 )

src/kotlin/sequential/graph/bfs/GridBreadthFirstTraversal.kt

@@ -0,0 +1,79 @@
+package sequential.graph.bfs.grid
+
+import java.util.*
+
+
+private typealias Graph<T> = Array<Array<out T>>
+
+private typealias Queue = ArrayDeque<Pair<Int, Int>>
+
+
+// Grid traversal directions represented as (row, col): left, up, right, down.
+private val DIRECTIONS = arrayOf(0 to -1, -1 to 0, 0 to 1, 1 to 0)
+
+
+fun <T> Graph<T>.bfs(rootRow: Int, rootCol: Int): Collection<T> {
+    val graph = this
+    require(graph.isValid(rootRow, rootCol)) { "Invalid graph." }
+
+    val rows = graph.size
+    val cols = graph[0].size
+    val rowBounds = 0 until rows
+    val colBounds = 0 until cols
+
+    val explored = Array(rows) { BooleanArray(cols) { false } }
+    val traversed = mutableListOf<T>()
+    val searchQueue = Queue()
+
+    searchQueue += rootRow to rootCol
+    while (searchQueue.isNotEmpty()) {
+        val (row, col) = searchQueue.removeFirst()
+
+        if (!explored[row][col] && graph[row][col] != null) {
+            explored[row][col] = true
+            traversed += graph[row][col]
+
+            for ((stepRow, stepCol) in DIRECTIONS) {
+                val nextRow = row + stepRow
+                val nextCol = col + stepCol
+
+                if (nextRow in rowBounds && nextCol in colBounds)
+                    searchQueue += nextRow to nextCol
+            }
+        }
+    }
+
+    return traversed
+}
+
+
+private fun <T> Graph<T>.isValid(rootRow: Int, rootCol: Int): Boolean {
+    val graph = this
+
+    // check if graph is not empty.
+    if (graph.isEmpty() || graph[0].isEmpty()) return false
+    // check if root vertex is valid.
+    if (graph.getOrNull(rootRow)?.getOrNull(rootCol) == null) return false
+
+    val cols = graph[0].size
+
+    // check if graph dimensions are valid.
+    for (row in graph)
+        if (row.size != cols) return false
+
+    return true
+}
+
+
+fun main() {
+
+    val graph = arrayOf(
+        arrayOf(3, 2, 1),
+        arrayOf(1, 4, 4),
+        arrayOf(9, 3, null)
+    )
+
+    println(
+        graph.bfs(0, 0)
+    )
+}