Graph Traversal via DFS and BFS

Author: JakubSchwenkbeck

src/main/scala/algorithms/graph/BFS.scala

@@ -0,0 +1,33 @@
+package algorithms.graph
+
+import datastructures.graph.Graph
+import datastructures.basic.Queue
+
+/// Breadth-First Search (BFS)
+/// Traverses the graph level by level from a given start node
+/// Uses a queue-based approach
+
+/// Runs in O(V + E) time complexity
+
+def BFS[T](graph: Graph[T], start: T): List[T] = {
+  val visited = scala.collection.mutable.Set[T]()
+  val queue = new Queue[T]()
+  val result = scala.collection.mutable.ListBuffer[T]()
+
+  queue.enqueue(start)
+  visited.add(start)
+
+  while (!queue.isEmpty) {
+    val node = queue.dequeue().get
+    result.append(node)
+
+    for ((neighbor, _) <- graph.getNeighbors(node)) {
+      if (!visited.contains(neighbor)) {
+        visited.add(neighbor)
+        queue.enqueue(neighbor)
+      }
+    }
+  }
+
+  result.toList
+}

src/main/scala/algorithms/graph/DFS.scala

@@ -0,0 +1,35 @@
+package algorithms.graph
+
+import datastructures.graph.Graph
+import datastructures.basic.Stack
+
+/// Depth-First Search (DFS)
+/// Explores as deep as possible before backtracking
+/// Uses a stack-based approach
+
+/// Runs in O(V + E) time complexity
+
+def DFS[T](graph: Graph[T], start: T): List[T] = {
+  val visited = scala.collection.mutable.Set[T]()
+  val stack = new Stack[T]()
+  val result = scala.collection.mutable.ListBuffer[T]()
+
+  stack.push(start)
+
+  while (!stack.isEmpty) {
+    val node = stack.pop().get
+
+    if (!visited.contains(node)) {
+      visited.add(node)
+      result.append(node)
+
+      for ((neighbor, _) <- graph.getNeighbors(node).toList.reverse) {
+        if (!visited.contains(neighbor)) {
+          stack.push(neighbor)
+        }
+      }
+    }
+  }
+
+  result.toList
+}

src/test/scala/algorithms/graph/GraphTraversalTest.scala

@@ -0,0 +1,82 @@
+package algorithms.graph
+
+import datastructures.graph._
+import algorithms.graph.BFS
+import algorithms.graph.DFS
+import munit.FunSuite
+
+class GraphTraversalTest extends FunSuite {
+
+  test("BFS should return correct level-order traversal") {
+    val graph = new Graph[Char](false) // Undirected Graph
+    graph.addEdge('A', 'B')
+    graph.addEdge('A', 'C')
+    graph.addEdge('B', 'D')
+    graph.addEdge('C', 'E')
+
+    val result = BFS(graph, 'A')
+    val expected = List('A', 'B', 'C', 'D', 'E')
+
+    assertEquals(result, expected)
+  }
+
+  test("DFS should return correct depth-first traversal") {
+    val graph = new Graph[Char](false) // Undirected Graph
+    graph.addEdge('A', 'B')
+    graph.addEdge('A', 'C')
+    graph.addEdge('B', 'D')
+    graph.addEdge('C', 'E')
+
+    val result = DFS(graph, 'A')
+
+    // Possible valid DFS orders:
+    val expected1 = List('A', 'C', 'E', 'B', 'D')
+    val expected2 = List('A', 'B', 'D', 'C', 'E')
+
+    assert(expected1 == result || expected2 == result)
+  }
+
+  test("BFS should return a single node if no edges exist") {
+    val graph = new Graph[Int](false)
+    graph.addVertex(1)
+
+    val result = BFS(graph, 1)
+    assertEquals(result, List(1))
+  }
+
+  test("DFS should return a single node if no edges exist") {
+    val graph = new Graph[Int](false)
+    graph.addVertex(1)
+
+    val result = DFS(graph, 1)
+    assertEquals(result, List(1))
+  }
+
+  test("BFS should correctly traverse a directed graph") {
+    val graph = new Graph[Char](true) // Directed Graph
+    graph.addEdge('A', 'B')
+    graph.addEdge('A', 'C')
+    graph.addEdge('B', 'D')
+    graph.addEdge('C', 'E')
+
+    val result = BFS(graph, 'A')
+    val expected = List('A', 'B', 'C', 'D', 'E')
+
+    assertEquals(result, expected)
+  }
+
+  test("DFS should correctly traverse a directed graph") {
+    val graph = new Graph[Char](true) // Directed Graph
+    graph.addEdge('A', 'B')
+    graph.addEdge('A', 'C')
+    graph.addEdge('B', 'D')
+    graph.addEdge('C', 'E')
+
+    val result = DFS(graph, 'A')
+
+    val expected1 = List('A', 'C', 'E', 'B', 'D')
+    val expected2 = List('A', 'B', 'D', 'C', 'E')
+
+    assert(expected1 == result || expected2 == result)
+  }
+}