快排算法是一种本地算法，（即不需要额外的内存空间，就地排序）
- 基本思想：
从这个数列里找一个数作为基准点（支点）跟其它的数进行对比，小于或等于这个支点数的都放到左边，大的放到右边。完成一次排序，然后依次递归，当起始下标和末尾下标相遇是，排序结束，即整列数已经排列好了顺序。 - 快排为什么快呢？
简单的总结是：快排实现了最优下界。比如著名的称球问题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]
参考链接：
快排及随机化算法
数学之美番外篇：快排为什么那样快
