Fix QuickSort algorithm with 3-way implementation

Author: Romanow

.editorconfig

@@ -13,3 +13,4 @@ ktlint_standard_argument-list-wrapping = disabled
 ktlint_standard_parameter-list-wrapping = disabled
 ktlint_standard_trailing-comma-on-call-site = disabled
 ktlint_standard_trailing-comma-on-declaration-site = disabled
+ktlint_standard_no-multi-spaces = disabled

src/main/kotlin/ru/romanow/algorithms/QuickSort.kt

@@ -1,42 +1,69 @@
 package ru.romanow.algorithms
 
 class QuickSort {
-    fun sort(arr: IntArray, low: Int = 0, high: Int = arr.size - 1) {
-        if (low < high) {
-            val pivotIndex = partition(arr, low, high)
-            sort(arr, low, pivotIndex - 1)
-            sort(arr, pivotIndex + 1, high)
-        }
-    }
+    fun sort(arr: IntArray, low: Int = 0, high: Int = arr.lastIndex) {
+        if (low >= high) return
+
+        val pivot = arr[low] // В качестве опорного элемента берём первый элемент диапазона
+        var lt = low         // lt — граница области элементов, которые строго меньше pivot
+        var gt = high        // gt — граница области элементов, которые строго больше pivot
+        var index = low
+
+        // arr[low .. lt-1]  < pivot   – слева уже собраны элементы меньше pivot
+        // arr[lt  .. i-1]   == pivot  – за ними элементы равные pivot
+        // arr[i   .. gt]              – посередине остаётся необработанная область
+        // arr[gt+1 .. high] > pivot   - справа уже собраны элементы больше pivot
+        while (index <= gt) {
+            when {
+                arr[index] < pivot -> {
+                    // Если текущий элемент меньше pivot, его нужно переместить в область "< pivot",
+                    // тем самым расширяя область меньших элементов
+                    arr.swap(lt, index)
+
+                    // После обмена:
+                    // - элемент на позиции lt гарантированно < pivot
+                    // - элемент, пришедший на позицию i, уже был равен pivot
+                    //   (так как область [lt .. i-1] — это == pivot), либо это тот же элемент при lt == i
+                    lt++
+                    index++
+                }
 
-    private fun partition(arr: IntArray, low: Int, high: Int): Int {
-        val pivot = arr[high] // в качестве опрного элемента берем последний
-        // Когда начинается цикл перебора элементов массива, изначально никаких элементов ещё не сравнивалось,
-        // поэтому i находится вне границ массива (это значит, что пока нет ни одного элемента, подходящего под
-        // условие "меньше или равно опорному элементу").
-        // Далее внутри цикла мы увеличиваем i, если находим элемент, который подходит под данное условие.
-        // Таким образом, если встречается элемент, удовлетворяющий условию (`if (arr[j] <= pivotValue)`), мы сначала
-        // увеличиваем i, а потом меняем местами этот элемент с элементом на позиции i. То есть фактически мы постепенно
-        // формируем отсортированную часть массива, где все элементы слева от i + 1 гарантированно меньше или равны
-        // опорному элементу
-        var i = low - 1
-
-        // если arr[j] <= pivot, увеличиваем i и меняем местами arr[i] и arr[j]
-        //  таким образом, все элементы <= pivot собираются слева
-        for (j in low until high) {
-            if (arr[j] <= pivot) {
-                i++
-                arr.swap(i, j)
+                arr[index] > pivot -> {
+                    // Если текущий элемент больше pivot, его нужно переместить в область "> pivot"
+                    // Меняем местами arr[i] и arr[gt], тем самым расширяя область больших элементов справа
+                    arr.swap(index, gt)
+
+                    // После обмена:
+                    // - элемент на позиции gt гарантированно > pivot
+                    // - но элемент, пришедший на позицию i, ещё не проверен (он был из неизвестной области)
+                    // Поэтому уменьшаем только gt, а i НЕ увеличиваем — нужно проверить новый arr[i]
+                    gt--
+                }
+
+                else -> {
+                    // Если arr[i] == pivot, он уже находится в корректной средней области
+                    // Просто расширяем область равных элементов, продвигая i вперёд
+                    index++
+                }
             }
         }
-        // в конце arr[i + 1] и arr[high] меняются местами, чтобы поставить pivot на правильную позицию
-        arr.swap(i + 1, high)
-        return i + 1
+
+        // После завершения цикла выполняется:
+        // arr[low .. lt-1]  < pivot
+        // arr[lt  .. gt]    == pivot
+        // arr[gt+1 .. high] > pivot
+        //
+        // Средняя часть полностью состоит из pivot и уже находится на своём окончательном месте — её сортировать не нужно.
+
+        // Рекурсивно сортируем только области,
+        // содержащие элементы строго меньше и строго больше pivot.
+        sort(arr, low, lt - 1)
+        sort(arr, gt + 1, high)
     }
 
     private fun IntArray.swap(i: Int, j: Int) {
-        val temp = this[i]
+        val tmp = this[i]
         this[i] = this[j]
-        this[j] = temp
+        this[j] = tmp
     }
 }