JarnikPrim for MST

Author: JakubSchwenkbeck

src/main/scala/algorithms/graph/JarnikPrim.scala

@@ -0,0 +1,55 @@
+package algorithms.graph
+
+import datastructures.graph.Graph
+import datastructures.basic.PriorityQueue
+import scala.collection.mutable
+import scala.util.control.Breaks._
+
+/// Jarník-Prim’s Algorithm
+/// Computes the Minimum Spanning Tree (MST) of a weighted graph
+/// Uses a greedy approach with a priority queue to select the lightest edge
+/// Works for connected, undirected graphs
+
+/// Returns a set of edges forming the MST
+
+/// The algorithm runs in O(E log V) time complexity
+
+def jarnikPrim[T](graph: Graph[T]): Set[(T, T, Double)] = {
+  val vertices = graph.getVertices.toList
+  if (vertices.isEmpty) return Set.empty // Handle empty graph
+
+  val mstEdges = mutable.Set[(T, T, Double)]()
+  val visited = mutable.Set[T]()
+  val priorityQueue = PriorityQueue[(T, T, Double)]()(Ordering.by(-_._3)) // Min-Heap
+
+  //  Start from an arbitrary vertex
+  val start = vertices.head
+  visited.add(start)
+
+  // Add all edges from the start vertex to the priority queue
+  for ((neighbor, weight) <- graph.getNeighbors(start)) {
+    priorityQueue.enqueue((start, neighbor, weight))
+  }
+
+  //  Main loop
+  while (visited.size < vertices.size && !priorityQueue.isEmpty) {
+    breakable {
+      val (u: T, v: T, weight: Double) = priorityQueue.dequeue().get
+
+      if (visited.contains(v)) break // Ignore edges leading to already visited nodes
+
+      // Add the edge to MST
+      mstEdges.add((u, v, weight))
+      visited.add(v)
+
+      // Add new edges from v to priority queue
+      for ((neighbor, w) <- graph.getNeighbors(v)) {
+        if (!visited.contains(neighbor)) {
+          priorityQueue.enqueue((v, neighbor, w))
+        }
+      }
+    }
+  }
+
+  mstEdges.toSet
+}

src/test/scala/algorithms/graph/JarnikPrimTest.scala

@@ -0,0 +1,41 @@
+package algorithms.graph
+
+import munit.FunSuite
+import datastructures.graph.Graph
+import algorithms.graph.jarnikPrim
+
+class JarnikPrimTest extends FunSuite {
+
+  test("Jarník-Prim should compute MST correctly") {
+    val graph = new Graph[String](isDirected = false)
+    graph.addEdge("A", "B", 1.0)
+    graph.addEdge("A", "C", 3.0)
+    graph.addEdge("B", "C", 1.0)
+    graph.addEdge("B", "D", 4.0)
+    graph.addEdge("C", "D", 1.0)
+    graph.addEdge("C", "E", 5.0)
+    graph.addEdge("D", "E", 2.0)
+
+    val mst = jarnikPrim(graph)
+
+    val expectedMST = Set(
+      ("A", "B", 1.0),
+      ("B", "C", 1.0),
+      ("C", "D", 1.0),
+      ("D", "E", 2.0)
+    )
+
+    assertEquals(mst.size, expectedMST.size)
+    assertEquals(mst.map(e => (e._1, e._2, e._3)), expectedMST)
+  }
+
+  test("Jarník-Prim should handle a single-node graph") {
+    val graph = new Graph[String](isDirected = false)
+    graph.addVertex("A")
+
+    val mst = jarnikPrim(graph)
+
+    assertEquals(mst, Set.empty)
+  }
+
+}

src/test/scala/algorithms/graph/JohnsonTest.scala

@@ -32,7 +32,7 @@ class JohnsonTest extends FunSuite {
   }
 
   /* Kind of not working lmao. this is caused by the Sentinel T value used
-  
+
   test("Johnson's Algorithm should detect a negative cycle") {
     val graph = new Graph[String](isDirected = true)