Kt版各常用排序算法

常用排序算法

排序算法	时间复杂度	时间复杂度
冒泡排序	O(n*n)	O(1)
插入排序	O(n*n)	O(1)
快速排序	O(logn)	O(1)

• 插入排序

fun insertSort(array: IntArray) {
        if (array.size <= 1) {
            return
        }
        for (i in 1 until array.size) {
            val anchor = array[i]
            var j = i - 1
            while (j >= 0) {
                if (array[j] > anchor) {
                    array[j + 1] = array[j]
                } else {
                    break
                }
                j--
            }
            array[j + 1] = anchor
        }
    }

• 快速排序

fun quickSort(array: IntArray) {
        //1.分区
        //2.递归
        quickSortReal(array, 0, array.size - 1)

    }

    private fun quickSortReal(array: IntArray, p: Int, r: Int) {
        if (p >= r) return
        val q = quickSortPart(array, p, r)
        quickSortReal(array, p, q - 1)
        quickSortReal(array, q + 1, r)
    }

    private fun quickSortPart(array: IntArray, p: Int, r: Int): Int {
        val anchor = array[r]
        var i = p
        for (j in p until r) {
            if (array[j] < anchor) {
                val temp = array[i]
                array[i] = array[j]
                array[j] = temp
                i += 1
            }
        }
        array[r] = array[i]
        array[i] = anchor
        return i
    }

• 冒泡排序

    fun bubbleSort(array: IntArray) {
        if (array.size <= 1) {
            return
        }
        for (i in 0 until array.size - 1) {
            var changeFlag = false
            for (j in 0 until array.size - i - 1) {
                if (array[j] > array[j + 1]) {
                    val temp = array[j + 1]
                    array[j + 1] = array[j]
                    array[j] = temp
                    changeFlag = true
                }
            }
            if (!changeFlag) {
                break
            }
        }
    }