算法系列之--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的算法实战比较》