算法系列之--Javascript和Kotlin的快速排序算法（原）

        上一节我们学习了基数排序算法，这一节来学习快速排序算法，算法系列文章目录在这里。

介绍

        从这个快速排序算法的名字就可以看出他非常快，有多块呢？在平均状况下，排序n个项目要O(n log n)次比较。 在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(n log n)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
        他的算法思路是，选择一个基准，小于基准的放在左边，大于基准的放在右边，然后左边的队列和右边队列排列之后分别进行上述运算，重复递归，具体步骤：
        1. 选择一个序列的某个值作为参考值，然后从序列左右两边索引同时与此参考值对比，遇到左边某个元素大于参考值，并且右边某个元素小于参考值时，交换左右元素，并且左右索引向中间逼近
        2. 当左右两边索引碰撞时，序列就拆分为左右两部分，分别递归步骤1

效率

        平均时间复杂度O(n log n)
        最优时间复杂度O(n log n)
        最坏时间复杂度O(n^2)
        什么情况下出现最坏的情况？ 当每次选择的基准都是序列中最大值的时候，但这种情况并不常见(每次都能选到那个最大值作为基准也真是牛逼了)

源码

Js源码

let list = [123456, 4, 8, 23, 5, 13, 323, 1, 9, 2, 3]
let swap = function (x, y) {
    let temp = list[x]
    list[x] = list[y]
    list[y] = temp
}
let sort = function (start, end) {
    if (start >= end) {
        return
    }
    let mid = list[end]
    let left = start
    let right = end - 1
    while (left < right) {
        //比较左右两边的值，让其小于参考值的放在列表左边，大于参考值的放在列表右边
        while (list[left] <= mid && left < right) {
            left++
        }
        while (list[right] >= mid && left < right) {
            right--
        }
        //此时遇到了 list[left]>mid>list[right]，需要交换两侧
        swap(left, right)
    }
    if (list[left] > list[end]) {
        swap(left, end)
    } else {
        left++
    }
    //递归拆分列表
    sort(start, left - 1)
    sort(left + 1, end)
}

Kotlin源码

private var ARRAY_COUNT = 100000
/*
 * 获取随机数列
 */
private fun getSortList(): IntArray {
    var sortList = IntArray(ARRAY_COUNT)
    var ra = Random()
    for (i in sortList.indices) {
        sortList[i] = ra.nextInt(ARRAY_COUNT * 10)
    }
    return sortList
}
/*
 * 交换数列元素
 */
private fun swapByIndex(list: IntArray, x: Int, y: Int) {
    var temp = list[x]
    list[x] = list[y]
    list[y] = temp
}
/*
快速排序的循环
 */
fun loopForKuaipai(list: IntArray, start: Int, end: Int) {
    if (start >= end) {
        return
    }
    var mid = list[end]
    var left = start
    var right = end - 1
    while (left < right) {
        //比较左右两边的值，让其小于参考值的放在列表左边，大于参考值的放在列表右边
        while (list[left] <= mid && left < right) {
            left++
        }
        while (list[right] >= mid && left < right) {
            right--
        }
        //此时遇到了 list[left]>mid>list[right]，需要交换两侧
        swapByIndex(list, left, right)
    }
    if (list[left] > list[end]) {
        swapByIndex(list, left, end)
    } else {
        left++
    }
    //递归拆分列表
    loopForKuaipai(list, start, left - 1)
    loopForKuaipai(list, left + 1, end)
}
/*
 * 快速排序
 */
private fun kuaipai() {
    var sortList = getSortList()
    loopForKuaipai(sortList, 0, sortList.size - 1)
}

        到这里，算法系列的介绍就结束了，希望该系列可以作为一个入门的引子，带大家进入算法的世界，感受算法的魅力。

        各个算法的Kotlini版本性能测试结果请看《算法系列之--Kotlin的算法实战比较》