Go语言实现快排+随机快排

快排算法是一种本地算法，（即不需要额外的内存空间，就地排序）

基本思想：
从这个数列里找一个数作为基准点（支点）跟其它的数进行对比，小于或等于这个支点数的都放到左边，大的放到右边。完成一次排序，然后依次递归，当起始下标和末尾下标相遇是，排序结束，即整列数已经排列好了顺序。
快排为什么快呢？
简单的总结是：快排实现了最优下界。比如著名的称球问题12个小球有一个是坏的（轻或重），现在呢有一架天平，问最少可用多少次就能确定哪个小球是坏的，并且指出它是轻了还是重了。答案是三次，称三次就能得出结论。等概率最优。时间复杂度为O(nlgn)（n乘以以10为底n的对数）
快排为什么好像不那么快呢？
当输入的数列是一个已经排序好的数列时（顺序或逆序），就慢了，因为它无法找到一个支点是两边等分的，无法做到等概率化，这是快排的最坏的情况，快排此时傻眼中。。。时间复杂度为O(n*n)但是没关系，下面第二种实现随机化快排算法可以弥补这个缺憾, 它不再关心你的输入数列是什么。

（1）基本快排算法，本示例用输入数列的第一个值作为排序支点。

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    // get the random numbers
    origin := rand.Perm(10)
    fmt.Println("origin:", origin)
    quickSort(origin, 0, len(origin))
    fmt.Println("quick sort:", origin)

}

func quickSort(list []int, start, end int) {
    if end-start > 1 {
        // get the pivot
        mid := partition(list, start, end)
        // left sort
        quickSort(list, start, mid)
        // right sort
        quickSort(list, mid+1, end)
    }
}

func partition(list []int, begin, end int) (i int) {
    cValue := list[begin]
    i = begin
    for j := i + 1; j < end; j++ {
        if list[j] < cValue {
            i++ // 这里一定要先加1后在交换值，因为支点现在不必交换，现在i 和 j（小于支点和大于支点）正在划分边界
            list[j], list[i] = list[i], list[j]
            fmt.Println("list:", list)
        }
    }
/* 到此，i和j的边界已经划分完成，把i对应的值和支点对应的值交换后，就符合了快分的要求：i左边对应的值都小于等于且右边的都大于支点对应的值
此时i的值就是新的支点, 对应的值就是新的主元
*/
    list[i], list[begin] = list[begin], list[i]
    return i
}

结果：

root@slave2:~# go run quickSort.go 
origin: [9 4 2 6 8 0 3 1 7 5]
quick sort: [0 1 2 3 4 5 6 7 8 9]

（2）随机快速排序算法
这个需要让每次的主元（就是那个被比较值）随机。实现如下：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    //origin := rand.Perm(20) //伪随机数
    origin := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("origin:", origin)
    randomQuickSort(origin, 0, len(origin))
    fmt.Println("quick sort:", origin)

}

func randomQuickSort(list []int, start, end int) {
    if end-start > 1 {
        // get the pivot
        mid := randomPartition(list, start, end)
        randomQuickSort(list, start, mid)
        randomQuickSort(list, mid+1, end)
    }
}

func randomPartition(list []int, begin, end int) int {
    // 生成真随机数
    i := randInt(begin, end)
    fmt.Println("random number:", i)
    // 下面这行是核心部分，随机选择主元， 如果没有此次交换，就是普通快排
    list[i], list[begin] = list[begin], list[i]
    return partition(list, begin, end)
}

func partition(list []int, begin, end int) (i int) {
    cValue := list[begin]
    i = begin
    for j := i + 1; j < end; j++ {
        if list[j] < cValue {
            i++
            list[j], list[i] = list[i], list[j]
        }
    }
    list[i], list[begin] = list[begin], list[i]
    return i
}

// 真随机数
func randInt(min, max int) int {
    rand.Seed(time.Now().UnixNano())
    return min + rand.Intn(max-min)
}

为了显示随机快排对有序数列的处理要优于普通快排，特意输入了0-10的有序数列，测试结果如下：
普通快排：

root@slave2:~# go run quickSort.go 
origin: [1 2 3 4 5 6 7 8 9]
random number: 6
random number: 8
random number: 2
random number: 7
random number: 5
random number: 7
random number: 6
random number: 7
quick sort: [1 2 3 4 5 6 7 8 9]

随机快排：

root@slave2:~# go run randomQuickSort.go 
origin: [1 2 3 4 5 6 7 8 9]
random number: 7
random number: 6
random number: 4
random number: 1
random number: 2
quick sort: [1 2 3 4 5 6 7 8 9]

参考链接：
快排及随机化算法
 数学之美番外篇：快排为什么那样快

Go语言实现快排+随机快排

推荐阅读更多精彩内容