在数组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里的系数快排是最小的