python快速排序

快速排序

快速排序是最常用的一种排序算法，包括C的qsort，C++和Java的sort，都采用了快排（C++和Java的sort经过了优化，还混合了其他排序算法）。

快排最坏情况 𝑂(𝑛2) ，但平均效率 𝑂(𝑛lg𝑛) ，而且这个 𝑂(𝑛lg𝑛) 记号中隐含的常数因子很小，快排可以说是最快的排序算法，它还是就地排序。

快速排序是基于分治策略的。对一个子数组A[p…r]快速排序的分治过程的三个步骤为：

1、分解

数组A[p…r]被划分成两个（可能空）子数组A[p…q-1]和A[q+1…r]，使得A[p…q-1]中的每个元素都小于等于A[q]，且小于等于A[q+1…r]中的元素。下标q也在这个划分过程中进行计算。

2、解决

通过递归调用快速排序，对子数组A[p…q-1]和A[q+1…r]排序。

3、合并

因为两个子数组就是原地排序的，将它们的合并不需要操作：整个数组A[p…r]已排序。

快速排序伪代码
QuickSort(A, p, r)
if p < r
q=Partition(A, p, r)
QuickSort(A, p, q-1)
QuickSort(A, q+1, r)

Partition(A, p, r)
x = A[r]
i = p-1
for j = p to r-1
if A[j]<=x
i=i+1
exchange A[i] with A[j]
exchange A[i+1] with A[r]
Return i+1
我们给出PARTITION代码中第3行至第8行迭代的循环不变式：

每一轮迭代的开始，对于任何数组下标k，有：

如果 𝑝≤𝑘≤𝑖 ，则 𝐴[𝑘]≤𝑥 。
如果 𝑖+1≤𝑘≤𝑗−1 ，则 𝐴[𝑘]>𝑥 。
如果 𝑘=𝑟 ，则 𝐴[𝑘]=𝑥 。
下面便是证明这个循环不变式：

初始化：循环开始前，有 𝑖=𝑝−1 和 𝑗=𝑝 。不存在k使得 𝑝≤𝑘≤𝑖 或 𝑖+1≤𝑘≤𝑗−1 ，所以1)和2)成立。程序第一行代码里的 𝑥=𝐴[𝑟] 使得条件3)成立。
保持：根据第4行代码的比较结果，有两种情况：
(1) 𝐴[𝑗]>𝑥 时，仅做一个j增加1的操作，所以条件1)和3)不受影响。j增加后 𝐴[𝑗−1]>𝑥 ，又因为 𝐴[1…𝑗−2] 在迭代前同样都大于x，所以条件2)成立；
(2) 𝐴[𝑗]≤𝑥 时，i增加1，因为 𝐴[𝑝…𝑖−1] 都小于等于x，而 𝐴[𝑖] 也小于等于x，所以 𝐴[𝑝…𝑖] 都小于等于x，条件1)成立。j也增加1，与情况1一样，条件2)和条件3)也都成立。 终止：循环结束时j=r，根据条件1) 𝐴[𝑝…𝑖] 都会小于等于x，而 𝐴[𝑖+1…𝑟−1] 都大于x。

#快速排序代码
def quickSort(data, start, end):
    i = start
    j = end
    #i与j重合时，一次排序结束
    if i >= j:
        return
    #设置最左边的数为基准值
    flag = data[start]
    while i < j:
        while i<j and data[j] >= flag:
            j -= 1
        #找到右边第一个小于基准的数，赋值给左边i。此时左边i被记录在flag中
        data[i] = data[j]
        while i<j and data[i] <= flag:
            i += 1
        #找到左边第一个大于基准的数，赋值给右边的j。右边的j的值和上面左边的i的值相同
        data[j] = data[i]
    #由于循环以i结尾，循环完毕后把flag值放到i所在位置。
    data[i] = flag
    #除去i之外两段递归
    quickSort(data, start, i-1)
    quickSort(data, i+1, end)
    
if __name__=="__main__":
    data = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21] 
    quickSort(data,0, len(data)-1)
    print(data)
    #输出结果为[5, 7, 10, 15, 17, 21, 24, 27, 30, 36, 45, 50]
	#希望能对各位有所帮助！！！