定义

快速排序使用了分而治之的策略（divide and conquer，D&C），一种著名的递归式问题解决方法。

步骤

快速排序的实现原理有三个步骤：
(1) 选择基准值。
(2) 将数组分成两个子数组：小于基准值的元素和大于基准值的元素。
(3) 对这两个子数组进行快速排序。

简单实现

根据实现原理可以写出如下的代码实现：

def quick_sort(arr):
    if len(arr) < 2:
        return arr
    else:
        pivot = arr[0]           #基准数
        less = [i for i in arr[1:] if i <= pivot]       #小于等于基准数的数组
        greater = [i for i in arr[1:] if i > pivot]    #大于基准数的数组
        return quick_sort(less) + [pivot] + quick_sort(greater)

一次遍历

这个实现中需要遍历两次原数组，能不能只遍历一次就把元素分成两个子数组呢？答案当然是肯定的。其实就是快速排序比较正宗的实现方法：挖坑和填坑。
以下面的数组为例

原数组

简单的选择第一个元素为基准，这样就出现了一个坑：下标为0的位置

基准

从右边开始找到第一个小于基准的元素即下标5的元素，把该元素的值放到下标为0的位置

填第一个坑

从左边坑(下标为0的位置)的下一个元素开始找到第一个大于等于基准的元素即下标为4的元素，把该元素的值放到第二个坑的位置(下标5处)

填第二个坑

基准入列

此时以下标4为界线分成了两个数组，然后对两个数组分别按照上述步骤进行排序即可。

数组切割

代码实现

def quick_sort(arr):
    if len(arr) < 2:
        return arr
    else:
        pivot = arr[0]
        i = 0
        j = len(arr) - 1
        while i < j:
            while i < j and arr[j] >= pivot:
                j -= 1

            if i < j:
                arr[i] = arr[j]
                i += 1

            while i < j and arr[i] < pivot:
                i += 1

            if i < j:
                arr[j] = arr[i]
                j -= 1

        arr[i] = pivot
        return quick_sort(arr[:i]) + [pivot] + quick_sort(arr[i+1:])

继续优化

针对第二种实现方法，还有可以再次进行优化就是在原数组上进行操作，不对数组进行切割。

def quick_sort(arr, l, r):
    if l >= r:
        return []

    pivot = arr[l]
    i = l
    j = r
    while i < j:
        while i < j and arr[j] >= pivot:
            j -= 1

        if i < j:
            arr[i] = arr[j]
            i += 1

        while i < j and arr[i] < pivot:
            i += 1

        if i < j:
            arr[j] = arr[i]
            j -= 1

    arr[i] = pivot
    return quick_sort(arr, l, i) + [pivot] + quick_sort(arr, i+1, r)

时间复杂度

快速排序算法的平均时间复杂度为 O(NlogN)。快排的最差情况为序列完全有序，此时快排退化为冒泡排序，时间复杂度为 O(n2) 。

快速排序的优化

快速排序基准的选择对于后续的排序有一定的影响，选择基准有几种方法：首元素、随机选择法、三数中值分割法等。
对于元素较少或接近有序的数组来说，快速排序平均性能比插入排序差。因此可以先利用快速排序把数组分割之后，再利用插入排序进行小数组的排序。