implement the union find structure aswell as kruskal for MST

Author: JakubSchwenkbeck

src/main/scala/algorithms/graph/Kruskal.scala

@@ -0,0 +1,38 @@
+package algorithms.graph
+
+import datastructures.graph.Graph
+import datastructures.union.UnionFind
+import scala.collection.mutable
+
+/// Kruskal’s Algorithm
+/// Computes the Minimum Spanning Tree (MST) of a weighted graph using a greedy approach
+/// It sorts all the edges and adds them to the MST, ensuring no cycles are formed by using Union-Find.
+///
+/// The algorithm runs in O(E log E) time complexity due to sorting the edges
+
+def kruskal[T](graph: Graph[T]): Set[(T, T, Double)] = {
+  val edges = graph.getEdges.toList
+  if (edges.isEmpty) return Set.empty // Handle empty graph
+
+  // Initialize UnionFind for vertices
+  val uf = new UnionFind[Int]()
+  graph.getVertices.foreach(v => uf.addElement(graph.getVertices.toList.indexOf(v)))
+
+  // Sort edges by their weight
+  val sortedEdges = edges.sortBy(_.weight)
+
+  val mstEdges = mutable.Set[(T, T, Double)]()
+
+  // Iterate through sorted edges and add to MST if they don't form a cycle
+  for (edge <- sortedEdges) {
+    val srcIndex = graph.getVertices.toList.indexOf(edge.src)
+    val destIndex = graph.getVertices.toList.indexOf(edge.dest)
+
+    if (!uf.isConnected(srcIndex, destIndex)) {
+      uf.union(srcIndex, destIndex)
+      mstEdges.add((edge.src, edge.dest, edge.weight))
+    }
+  }
+
+  mstEdges.toSet
+}

src/main/scala/datastructures/union/UnionFind.scala

@@ -0,0 +1,58 @@
+package datastructures.union
+
+import scala.collection.mutable.ArrayBuffer
+
+/// A Union-Find (Disjoint Set) implementation with path compression and union by rank.
+///
+/// Time Complexity:
+/// - Find: O(α(n)), where α is the inverse Ackermann function (amortized time)
+/// - Union: O(α(n))
+/// - Size: O(1)
+/// - IsConnected: O(α(n))
+/// - AddElement: O(1)
+class UnionFind[T] {
+  private val parent: ArrayBuffer[Int] = ArrayBuffer.empty[Int]
+  private val rank: ArrayBuffer[Int] = ArrayBuffer.empty[Int]
+  private val elements: ArrayBuffer[T] = ArrayBuffer.empty[T]
+
+  def addElement(element: T): Unit = {
+    elements.append(element)
+    parent.append(parent.size)
+    rank.append(0)
+  }
+
+  private def find(index: Int): Int = {
+    if (parent(index) != index) {
+      parent(index) = find(parent(index)) // Path compression
+    }
+    parent(index)
+  }
+
+  def union(index1: Int, index2: Int): Unit = {
+    val root1 = find(index1)
+    val root2 = find(index2)
+
+    if (root1 != root2) {
+      // Union by rank
+      if (rank(root1) > rank(root2)) {
+        parent(root2) = root1
+      } else if (rank(root1) < rank(root2)) {
+        parent(root1) = root2
+      } else {
+        parent(root2) = root1
+        rank(root1) += 1
+      }
+    }
+  }
+
+  def isConnected(index1: Int, index2: Int): Boolean = {
+    find(index1) == find(index2)
+  }
+
+  def getParent(index: Int): Int = find(index)
+
+  def size: Int = parent.size
+
+  def getElement(index: Int): T = elements(index)
+
+}

src/test/scala/algorithms/graph/KruskalTest.scala

@@ -0,0 +1,41 @@
+package algorithms.graph
+
+import munit.FunSuite
+import datastructures.graph.Graph
+import algorithms.graph.kruskal
+
+class KruskalTest extends FunSuite {
+
+  test("Kruskal 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 = kruskal(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("Kruskal should handle a single-node graph") {
+    val graph = new Graph[String](isDirected = false)
+    graph.addVertex("A")
+
+    val mst = kruskal(graph)
+
+    assertEquals(mst, Set.empty)
+  }
+
+}