implemented randomized and deterministic Median searches (QuickSelect and MdM) for Quciksort

Author: JakubSchwenkbeck

src/main/scala/algorithms/search/MedianOfMedianSearch.scala

@@ -0,0 +1,35 @@
+package algorithms.search
+
+/// Deterministic Median of Medians Search returns the median of the Array A
+/// Used for a deterministic O(n) pivot of QuickSort
+/// This runs in O(n) because T(n) <= T(n/5) + T(7n / 10) + O(n)
+
+def MdMSelect(A: Array[Int], k: Int): Int = {
+  if (A.length <= 25) return bruteForceMedian(A, k) // Use sorting for small arrays
+
+  // Divide A into groups of 5 and find medians
+  val groups = A.grouped(5).toArray
+  val Medians = groups.map(group => bruteForceMedian(group, group.length / 2))
+
+  // Recursively find median of medians
+  val mdm = MdMSelect(Medians, Medians.length / 2)
+
+  // Partition around mdm
+  val (less, equal, greater) = A.foldLeft((List[Int](), List[Int](), List[Int]())) {
+    case ((less, equal, greater), elem) =>
+      if (elem < mdm) (elem :: less, equal, greater)
+      else if (elem > mdm) (less, equal, elem :: greater)
+      else (less, elem :: equal, greater)
+  }
+
+  if (less.length >= k) {
+    MdMSelect(less.toArray, k)
+  } else if (less.length + equal.length >= k) {
+    mdm
+  } else {
+    MdMSelect(greater.toArray, k - less.length - equal.length)
+  }
+}
+def bruteForceMedian(A: Array[Int], k: Int): Int = {
+  A.sorted.apply(k)
+}

src/main/scala/algorithms/search/QuickSelect.scala

@@ -0,0 +1,35 @@
+package algorithms.search
+
+import scala.annotation.tailrec
+import scala.util.Random
+
+/// randomized QuickSelect searches the k-smallest Number in a set of unordered numbers
+/// This is a more generalized approach to the Median search for QuickSort
+///
+/// Due to a randomized pick of the pivot, the Runtime is O(n):
+/// T(n) <= T(3/4 * n) + O(n)
+
+@tailrec
+def quickSelect(A: Array[Int], k: Int): Int = {
+  require(A.nonEmpty, "Array must not be empty")
+  if (A.length == 1) return A(0)
+
+  // Random pivot selection
+  val pivot = A(Random.nextInt(A.length))
+
+  // Partition elements efficient with Lists
+  val (less, equal, greater) = A.foldLeft((List[Int](), List[Int](), List[Int]())) {
+    case ((less, equal, greater), elem) =>
+      if (elem < pivot) (elem :: less, equal, greater)
+      else if (elem > pivot) (less, equal, elem :: greater)
+      else (less, elem :: equal, greater)
+  }
+
+  if (less.length >= k) {
+    quickSelect(less.toArray, k)
+  } else if (less.length + equal.length >= k) {
+    pivot
+  } else {
+    quickSelect(greater.toArray, k - less.length - equal.length)
+  }
+}

src/main/scala/algorithms/sort/RadixSort.scala

@@ -6,7 +6,7 @@ package algorithms.sort
 /// Example:
 /// val Arr = Array(170, 45, 75, 90, 802, 24, 2, 66)
 /// val result = radixSort(Arr, 3)
-/// println(result.mkString(", ")) // Returns Array(2, 24, 45, 66, 75, 90, 170, 802)
+/// println(result) // Returns Array(2, 24, 45, 66, 75, 90, 170, 802)
 
 def radixSort(A: Array[Int], d: Int): Array[Int] = {
   var output = A.clone()

src/main/scala/algorithms/sort/improvedQuickSort.scala

@@ -0,0 +1,44 @@
+package algorithms.sort
+
+import algorithms.search.quickSelect
+import algorithms.search.MdMSelect
+
+/// Randomized QuickSort implementation using QuickSelect for pivot selection
+/// This achieves an expected runtime of O(n log n) due to the randomized pivot.
+/// The worst-case runtime remains O(n^2), but it is highly unlikely in practice
+///
+/// The algorithm partitions the array around the pivot and recursively sorts both halves.
+def randomizedQuickSort(A: Array[Int]): Array[Int] = {
+  if (A.length < 2) return A
+
+  val p: Int = quickSelect(A, A.length / 2) // Randomized pivot selection
+
+  val (less, equal, greater) = A.foldLeft((List[Int](), List[Int](), List[Int]())) {
+    case ((less, equal, greater), elem) =>
+      if (elem < p) (elem :: less, equal, greater)
+      else if (elem > p) (less, equal, elem :: greater)
+      else (less, elem :: equal, greater)
+  }
+
+  randomizedQuickSort(less.toArray) ++ equal ++ randomizedQuickSort(greater.toArray)
+}
+
+/// Deterministic QuickSort implementation using the Median of Medians pivot selection
+/// This guarantees an O(n log n) runtime in all cases, including the worst-case scenario.
+///
+/// The pivot is selected deterministically via MdMSelect, making this more robust
+/// than the randomized version for adversarial inputs.
+def deterministicQuickSort(A: Array[Int]): Array[Int] = {
+  if (A.length < 2) return A
+
+  val p: Int = MdMSelect(A, A.length / 2) // Deterministic pivot selection
+
+  val (less, equal, greater) = A.foldLeft((List[Int](), List[Int](), List[Int]())) {
+    case ((less, equal, greater), elem) =>
+      if (elem < p) (elem :: less, equal, greater)
+      else if (elem > p) (less, equal, elem :: greater)
+      else (less, elem :: equal, greater)
+  }
+
+  deterministicQuickSort(less.toArray) ++ equal ++ deterministicQuickSort(greater.toArray)
+}

src/test/scala/algorithms/sort/improvedQuickSortTest.scala

@@ -0,0 +1,66 @@
+package algorithms.sort
+
+import munit.FunSuite
+import algorithms.sort.randomizedQuickSort
+import algorithms.sort.deterministicQuickSort
+
+class improvedQuickSortTest extends FunSuite {
+  test("randomizedQuickSort sorts arrays correctly") {
+    val arr = Array(4, 2, 1, 5, 6, 3, 7, 12, 8, 10, 9, 11)
+    val res = randomizedQuickSort(arr)
+    assertEquals(res.toSeq, Array.range(1, 13).toSeq)
+  }
+  test("randomizedQuickSort sorts arrays  with negatives correctly") {
+    val arr = Array(-1, 4, 2, 1, -4, 5, 6, 3, 0, 7, 12, -3, 8, 10, 9, -2, 11)
+    val res = randomizedQuickSort(arr)
+    assertEquals(res.toSeq, Array.range(-4, 13).toSeq)
+  }
+
+  test("randomizedQuickSort sorts arrays with duplicates") {
+    val arr = Array(4, 2, 1, 5, 3, 2)
+    val res = randomizedQuickSort(arr)
+    assertEquals(res.toSeq, Array(1, 2, 2, 3, 4, 5).toSeq)
+  }
+
+  test("randomizedQuickSort handles singleton arrays") {
+    val arr = Array(1)
+    randomizedQuickSort(arr)
+    assertEquals(arr.toSeq, Array(1).toSeq)
+  }
+  test("randomizedQuickSort-sort handles empty arrays") {
+    val arr = Array.empty[Int]
+    randomizedQuickSort(arr)
+    assertEquals(arr.toSeq, Array.empty[Int].toSeq)
+  }
+
+  class deterministicQuickSortTest extends FunSuite {
+    test("deterministicQuickSort sorts arrays correctly") {
+      val arr = Array(4, 2, 1, 5, 6, 3, 7, 12, 8, 10, 9, 11)
+      deterministicQuickSort(arr)
+      assertEquals(arr.toSeq, Array.range(1, 13).toSeq)
+    }
+    test("deterministicQuickSort sorts arrays  with negatives correctly") {
+      val arr = Array(-1, 4, 2, 1, -4, 5, 6, 3, 0, 7, 12, -3, 8, 10, 9, -2, 11)
+      deterministicQuickSort(arr)
+      assertEquals(arr.toSeq, Array.range(-4, 13).toSeq)
+    }
+
+    test("deterministicQuickSort sorts arrays with duplicates") {
+      val arr = Array(4, 2, 1, 5, 3, 2)
+      deterministicQuickSort(arr)
+      assertEquals(arr.toSeq, Array(1, 2, 2, 3, 4, 5).toSeq)
+    }
+
+    test("deterministicQuickSort handles singleton arrays") {
+      val arr = Array(1)
+      deterministicQuickSort(arr)
+      assertEquals(arr.toSeq, Array(1).toSeq)
+    }
+    test("deterministicQuickSort-sort handles empty arrays") {
+      val arr = Array.empty[Int]
+      deterministicQuickSort(arr)
+      assertEquals(arr.toSeq, Array.empty[Int].toSeq)
+    }
+
+  }
+}