kotlin排序

private fun IntArray.print() {
    this.forEach {
        print("$it ")
    }
    println()
}

private fun IntArray.swap(i: Int, j: Int) {
    val tmp = this[i]
    this[i] = this[j]
    this[j] = tmp
}

/**
 * 冒泡排序：比较相邻的两个元素的大小
 */
fun bubble(nums: IntArray) {
    for (i in nums.indices) {
        for (j in 0 until nums.size - 1 - i) {
            if (nums[j] > nums[j + 1]) {
                nums.swap(j, j + 1)
            }
        }
    }
    nums.print()
}

/**
 * 选择排序：每次通过循环，我们选择最小的剩余元素并将其移动到正确的位置（即当前遍历的index位置）
 */
fun selectSort(nums: IntArray) {
    for (index in nums.indices) {
        var currentPosition = index
        for (j in index + 1 until nums.size) {
            if (nums[currentPosition] > nums[j]) {
                currentPosition = j
            }
        }
        nums.swap(currentPosition, index)
    }
    nums.print()
}

/**
 * 插入排序：对于每个未排序数据，在已排序序列中从后往前扫描，找到相应位置并插入
 * 注意：内层循环是在已排好序的列表中从后往前查找，当找到比自己小的数时，就插到它的后面，不能是从前往后，那样不一定可插队正确的位置。
 */
fun insertSort(nums: IntArray) {
    for (i in 1 until nums.size) {
        if (nums[i] < nums[i - 1]) {
            val needInsert = nums[i]
            for (j in i downTo 0) {
                if (nums[j] > needInsert) {
                    nums[j + 1] = nums[j]
                    nums[j] = needInsert
                }
            }
        }
    }
    nums.print()
}

/**
 * 希尔排序：插入排序类似，只是插入排序的 step 固定为 1，而希尔排序的 step 会变化直至 1
 */
fun shellSort(nums: IntArray) {
    var step = nums.size / 2
    while (step > 0) {
        for (i in step until nums.size) {
            var j = i
            while (j >= step && nums[j] < nums[j - step]) {
                nums.swap(j, j - step)
                j -= step
            }
        }
        step /= 2
    }
    nums.print()
}

/**
 * 快速排序：基准，左，右
 */
fun quickSort(nums: ArrayList<Int>): ArrayList<Int> {
    if (nums.size < 2) {
        return nums
    }
    val mid = nums[nums.size / 2]
    nums.removeAt(nums.size / 2)
    val left = nums.filter { it < mid } as ArrayList<Int>
    val right = nums.filter { it > mid } as ArrayList<Int>
    return (quickSort(left) + mid + quickSort(right)) as ArrayList<Int>
}

/**
 * 二分法查找：双指针
 */
fun search(target: Int, nums: IntArray): Int {
    var left: Int = 0
    var right: Int = nums.size - 1
    while (left < right) {
        val mid = (left + right) / 2
        when {
            target < nums[mid] -> {
                right = mid - 1
            }
            nums[mid] < target -> {
                left = mid + 1
            }
            else -> {
                return mid
            }
        }
    }
    return -1
}


/**
 * 归并排序：分治思想
 */
fun mergeSort(nums: IntArray): IntArray {
    nums.print()
    if (nums.size == 1) {
        return nums
    }
    val midPos = nums.size / 2
    val left = mergeSort(nums.slice(0 until midPos).toIntArray())
    val right = mergeSort(nums.slice(midPos until nums.size).toIntArray())
    return merge(left, right)
}

fun merge(l: IntArray, r: IntArray): IntArray {
    var result = intArrayOf()
    val left = l.toMutableList()
    val right = r.toMutableList()
    while (left.size > 0 && right.size > 0) {
        result += if (left[0] <= right[0]) {
            left.removeAt(0)
        } else {
            right.removeAt(0)
        }
    }
    result += left + right
    return result
}