在数组a中，设置一个值key为枢轴。在调整的过程中，设立两个指针low和high；之后逐渐减小high,增加low（low<=high）；并保证a[low]<key，a[high]>key;否则进行记录的交换
代码：
func QuickSort(a []int){
if len(a) <= 1{
return
}
key := a[0] //以第一个数为key
low := 0
high := len(a)-1
for low < high {
for low < high && a[high] > key { //开始从后往前找小与key的
high --
}
a[low] = a[high] //找到key,交换，交换
for low < high && a[low] <= key { //找到key,交换一次之后，换方向从前往后遍历
low ++
}
a[high] = a[low]
}
a[low] = key
go QuickSort(a[:low])
go QuickSort(a[low+1:])
}
测试：
func main(){
a := []int{0,10,19,24,61,5,121,9,11,34,21,22}
base_sort.QuickSort(a)
fmt.Println(a)//[0 5 9 10 11 19 21 22 24 34 61 121]
}
时间复杂度：
|
快速排序 |
O(N*log2N) |
O(N*log2N) |
O(N2) |
O(log2n)~O(n) |
最差情况下时间复杂度
最差的情况就是每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)。这种情况时间复杂度就好计算了，就是冒泡排序的时间复杂度：T[n] = n * (n-1) = n^2 + n;
最优情况
在最优情况下，Partition每次都划分得很均匀，如果排序n个关键字，其递归树的深度就为 [log2n]+1（ [x] 表示不大于 x 的最大整数），即仅需递归 log2n 次，需要时间为T（n）的话，第一次Partiation应该是需要对整个数组扫描一遍，做n次比较。然后，获得的枢轴将数组一分为二，那么各自还需要T（n/2）的时间（注意是最好情况，所以平分两半）。于是不断地划分下去，就有了O(N*log2N)
为什么用快排不用堆排：
隐藏在O里的系数快排是最小的
来源：CSDN
作者：田园园野
链接：https://blog.csdn.net/qq_36183935/article/details/80230002