implemented TimSort

Author: JakubSchwenkbeck

src/main/scala/algorithms/sort/TimSort.scala

@@ -0,0 +1,85 @@
+package algorithms.sort
+
+/// Hybrid sorting algorithm: Timsort
+/// Combines Insertion Sort for small partitions and Merge Sort for merging
+/// Example:
+/// val Arr = Array(5, 2, 9, 1, 5, 6)
+/// timSort(Arr, 64)
+/// println(Arr) // Returns (1, 2, 5, 5, 6, 9)
+/// Timsort runs in O(n log n) worst-case.
+def timSort(arr: Array[Int], k: Int = 64): Unit = {
+  require(arr != null, "Input array must not be null") // Ensure valid input
+
+  val n = arr.length
+
+  // Step 1: Sort small chunks with Insertion Sort
+  for (i <- 0 until n by k) {
+    val end = Math.min(i + k, n)
+    insertionSortInPlace(arr, i, end)
+  }
+
+  // Step 2: Merge sorted chunks with Merge Sort
+  var size = k
+  while (size < n) {
+    for (left <- 0 until n by 2 * size) {
+      val mid = Math.min(left + size, n)
+      val right = Math.min(left + 2 * size, n)
+
+      if (mid < right) merge(arr, left, mid, right)
+    }
+    size *= 2
+  }
+}
+
+// Helper function: Insertion Sort for a subarray
+private def insertionSortInPlace(arr: Array[Int], start: Int, end: Int): Unit = {
+  for (i <- start + 1 until end) {
+    val key = arr(i)
+    var j = i - 1
+
+    while (j >= start && arr(j) > key) {
+      arr(j + 1) = arr(j)
+      j -= 1
+    }
+    arr(j + 1) = key
+  }
+}
+
+// Helper function: Merge two sorted subarrays
+private def merge(arr: Array[Int], left: Int, mid: Int, right: Int): Unit = {
+  val leftArr = arr.slice(left, mid)
+  val rightArr = arr.slice(mid, right)
+
+  var i = 0
+  var j = 0
+  var k = left
+
+  while (i < leftArr.length && j < rightArr.length) {
+    if (leftArr(i) <= rightArr(j)) {
+      arr(k) = leftArr(i)
+      i += 1
+    } else {
+      arr(k) = rightArr(j)
+      j += 1
+    }
+    k += 1
+  }
+
+  while (i < leftArr.length) {
+    arr(k) = leftArr(i)
+    i += 1
+    k += 1
+  }
+
+  while (j < rightArr.length) {
+    arr(k) = rightArr(j)
+    j += 1
+    k += 1
+  }
+}
+
+// Return version of Timsort
+def returnTimSort(arr: Array[Int], k: Int = 64): Array[Int] = {
+  timSort(arr, k)
+  arr
+}

src/test/scala/algorithms/sort/TimSortTest.scala

@@ -0,0 +1,36 @@
+package algorithms.sort
+
+import algorithms.sort.timSort
+
+import munit.*
+
+class TimSortTest extends FunSuite {
+  test("timSort sorts arrays correctly") {
+    val arr = Array(4, 2, 1, 5, 6, 3, 7, 12, 8, 10, 9, 11)
+    timSort(arr)
+    assertEquals(arr.toSeq, Array.range(1, 13).toSeq)
+  }
+  test("timSort 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)
+    timSort(arr)
+    assertEquals(arr.toSeq, Array.range(-4, 13).toSeq)
+  }
+
+  test("timSort sorts arrays with duplicates") {
+    val arr = Array(4, 2, 1, 5, 3, 2)
+    timSort(arr)
+    assertEquals(arr.toSeq, Array(1, 2, 2, 3, 4, 5).toSeq)
+  }
+
+  test("timSort handles singleton arrays") {
+    val arr = Array(1)
+    timSort(arr)
+    assertEquals(arr.toSeq, Array(1).toSeq)
+  }
+  test("timSort-sort handles empty arrays") {
+    val arr = Array.empty[Int]
+    timSort(arr)
+    assertEquals(arr.toSeq, Array.empty[Int].toSeq)
+  }
+
+}