数据结构和算法（十三）快速排序

定义

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

算法步骤

• 挑选基准值：从数列中挑出一个元素，称为“基准”（pivot）。
• 分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成。
• 递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。递归到最底部的判断条件是数列的大小是零或一，此时该数列显然已经有序。

动图分析

过程分析

这六个数组成的无序序列[5,9,3,6,2,7]，由小到大排序。
按照快速排序算法，过程如下：

• 首先挑选基准值，把5当做基准值，然后分别从左右两端进行扫描。设置两个标志start和end，用来代表起始位置和末尾位置。
  
• 然后开始从后半部分开始扫描,如果扫描到的值大于基准数据，就让end加1,如果发现元素小于基准数据的值，就再将end位置的值赋值给start位置,同时start加1，7>5,所以end前移一个位置到2,2<5,所以把2添加到5的位置上，结果如下
  
• 然后开始从前半部分开始扫描，如果扫描到的值大于基准值，将start位置的值赋给end位置，同时end加1，
  如果小于基准值，就让start加1,9>4,所以将start位置值赋给end位置，结果如下
  

-然后开始从后半部分开始扫描,如果扫描到的值大于基准数据，就让end加1,如果发现元素小于基准数据的值，就再将end位置的值赋值给start位置,同时start加1，6>4,所以end移动一位到3，3<4，所以将3的位置的值赋值给start，同时start加1，结果如下

• 此时start和end位置重合，左边绿色都是小于基准值的数据，右面黄色都是大于基准值的数据，第一轮结果就完事了。
  
• 之后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。

python代码实现

def quick_sort(arr, start, end):
	# 递归退出的条件
	if start >= end:
		return
	# 将列表的第一个元素当做基准值
	temp = arr[start]
	# 设置从左到右的游标
	low = start
	# 设置从右到左的游标
	high = end
	while low < high:
		# 如果low与high未重合，high指向的元素比基准元素大，则high向左移动
		while low < high and arr[high] >= temp:
			high -= 1
		# 把high上面的元素放到low位置上
		arr[low] = arr[high]

		# 如果low与high未重合，low指向的元素比基准元素小，则low向右移动
		while low < high and arr[low] < temp:
			low += 1
        # 将low指向的元素放到high的位置上
		arr[high] = arr[low]

	# 退出循环后，low与high重合，此时所指位置为基准元素的正确位置  将基准元素放到该位置
	arr[low] = temp
	# 对基准元素左边的子序列进行快速排序
	quick_sort(arr, start, low-1)

    # 对基准元素右边的子序列进行快速排序
	quick_sort(arr, low+1, end)
	return arr


if __name__ == '__main__':
    arr = [5, 9, 3, 6, 2, 7]
    print(quick_sort(arr, 0, len(arr) - 1))

结果：

[2, 3, 5, 6, 7, 9]

时间复杂度

• 最优时间复杂度：$O(nlogn)$
• 最坏时间复杂度：$O(n^2)$

从一开始快速排序平均需要花费O(n log n)时间的描述并不明显。但是不难观察到的是分区运算，数组的元素都会在每次循环中走访过一次，使用O(n)的时间。

在最好的情况，每次我们运行一次分区，我们会把一个数列分为两个几近相等的片段。这个意思就是每次递归调用处理一半大小的数列。因此，在到达大小为一的数列前，我们只要作log n次嵌套的调用。这个意思就是调用树的深度是O(log n)。但是在同一层次结构的两个程序调用中，不会处理到原来数列的相同部分；因此，程序调用的每一层次结构总共全部仅需要O(n)的时间（每个调用有某些共同的额外耗费，但是因为在每一层次结构仅仅只有O(n)个调用，这些被归纳在O(n)系数中）。结果是这个算法仅需使用O(n log n)时间。

另一个方法是为Tn设立一个递归关系式，也就是需要排序大小为n的数列所需要的时间，在最好的情况下，因为一个单独的快速排序调用牵涉了O(n)操作，加上对n/2大小之数列的两个递归调用，这个关系式可以是
$$T(n)=O(n)+2T(n/2)->>T(n)=O(nlogn)$$

稳定性

快速排序是不稳定的，相同的值会出现左右轮换变化的情况。