Sorting in Kotlin just for fun and entertainment

sorting.kt

fun bubbleSort(arr: Array<Int>): Array<Int> {
    for (i in 0 until arr.size) {
        for (j in arr.size - 1 downTo i) {
            if (arr[i] > arr[j]) {
                swap(arr, i, j)
            }
        }
    }
    return arr
}

fun selectionSort(arr: Array<Int>): Array<Int> {
    for (i in 0 until arr.size) {
        var minIdx = i
        for (j in i until arr.size) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j
            }
        }
        swap(arr, i, minIdx)
    }
    return arr
}

fun mergeSort(arr: Array<Int>): Array<Int> {
    if (arr.size < 2) {
        return arr
    }

    val mid = arr.size / 2

    return merge(mergeSort(arr.copyOfRange(0, mid)), mergeSort(arr.copyOfRange(mid, arr.size)))
}

fun merge(left: Array<Int>, right: Array<Int>): Array<Int> {

    var leftCounter = 0
    var rightCounter = 0

    val result = arrayListOf<Int>()

    while (leftCounter < left.size && rightCounter < right.size) {
        if (left[leftCounter] < right[rightCounter]) {
            result.add(left[leftCounter++])
        } else {
            result.add(right[rightCounter++])
        }
    }

    while (leftCounter < left.size) {
        result.add(left[leftCounter++])
    }

    while (rightCounter < right.size) {
        result.add(right[rightCounter++])
    }

    return result.toTypedArray()
}

fun quickSort(arr: Array<Int>): Array<Int> {
    return quickSort(arr, 0, arr.size - 1)
}

fun quickSort(arr: Array<Int>, start: Int, end: Int): Array<Int> {

    if (start > end) {
        return arr
    }

    val pivotIdx = partition(arr, start, end)

    quickSort(arr, start, pivotIdx - 1)
    quickSort(arr, pivotIdx + 1, end)

    return arr
}

fun partition(arr: Array<Int>, start: Int, end: Int): Int {

    val pivot = arr[end]

    var i = start

    for (j in start until end) {
        if (arr[j] < pivot) {
            swap(arr, i, j)
            i++
        }
    }
    swap(arr, i, end)

    return i
}

private fun swap(arr: Array<Int>, i: Int, j: Int) {
    val temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp
}

fun main() {

    println(bubbleSort(arrayOf(1, 200, 250, 3, 2, -9)).toList())
    println(bubbleSort(arrayOf(1, 200, 250, 3, 2, -9, 0, 0, 1, 2, 40023420, 400)).toList())
    println(bubbleSort(arrayOf(1111, 2004134, 2501, 340912, 2, -9, 904910)).toList())

    println(selectionSort(arrayOf(1, 200, 250, 3, 2, -9)).toList())
    println(selectionSort(arrayOf(1, 200, 250, 3, 2, -9, 0, 0, 1, 2, 40023420, 400)).toList())
    println(selectionSort(arrayOf(1111, 2004134, 2501, 340912, 2, -9, 904910)).toList())

    println(mergeSort(arrayOf(1, 200, 250, 3, 2, -9)).toList())
    println(mergeSort(arrayOf(1, 200, 250, 3, 2, -9, 0, 0, 1, 2, 40023420, 400)).toList())
    println(mergeSort(arrayOf(1111, 2004134, 2501, 340912, 2, -9, 904910)).toList())

    println(quickSort(arrayOf(1, 200, 250, 3, 2, -9)).toList())
    println(quickSort(arrayOf(1, 200, 250, 3, 2, -9, 0, 0, 1, 2, 40023420, 400)).toList())
    println(quickSort(arrayOf(1111, 2004134, 2501, 340912, 2, -9, 904910)).toList())
}