golang ----------- 快速排序

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