算法-排序

/**
 * 冒泡排序 + 优化
 */
fun bubbleSort(array: Array<Int>) {
    if (array.isEmpty()) return
    for (i in 0 until  array.size - 1) {
        //交换边界
        var lastExchangeIndex = array.size - 1
        //数列是否有序
        var isSort = true
        var sortBorder = array.size - 1
        for(j in 0 until sortBorder) {
            if(array[j] > array[j + 1]) {
                val temp = array[j]
                array[j] = array[j + 1]
                array[j + 1] = temp
                isSort = false
                lastExchangeIndex = j
            }
        }
        sortBorder = lastExchangeIndex
        if (isSort) break
    }
}

/**
 * 插入排序
 */
fun insertionSort(array: Array<Int>) {
    for (i in 1 until array.size) {
        if (array[i] > array[i - 1]) {
            var temp = array[i]
            here@ for (j in i downTo 0)  {
                if (j > 0 && array[j - 1] < temp) {
                    array[j] = array[j-1]
                } else{
                    array[j] = temp
                    break@here
                }
            }
        }
    }
}

 

/**
 * 快速排序
 */
fun quickSort(array: Array<Int>, startIndex: Int, endIndex: Int) {
    if (startIndex >= endIndex) return
    var pivotIndex = partition(array, startIndex, endIndex)
    quickSort(array, startIndex, pivotIndex - 1)
    quickSort(array, pivotIndex + 1, endIndex)
}

fun partition(array: Array<Int>, startIndex: Int, endIndex: Int): Int{
    val pivot = array[startIndex]
    var left = startIndex
    var right = endIndex
    while (left != right) {
        while (right > left && array[right] < pivot) right--
        while (left < right && array[left] >= pivot) left++
        if (left < right) {
            val temp = array[left]
            array[left] = array[right]
            array[right] = temp
        }
    }
    array[startIndex] = array[left]
    array[left] = pivot
    return left
}