Python-快速排序
快速排序的介绍
快速排序(quick sort)的采用了分治的策略。
- 分治策略指的是：
将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。 - 快排的基本思想是：
在序列中找一个划分值，通过一趟排序将未排序的序列排序成 独立的两个部分，其中左边部分序列都比划分值小，右边部分的序列比划分值大，此时划分值的位置已确认，然后再对这两个序列按照同样的方法进行排序，从而达到整个序列都有序的目的。
快速排序的Python实现
（1）python语言特性实现
先来看一个 我更想称之为伪快排的快排代码：
def quick_sort(array):
if len(array) < 2:
return array
else:
pivot = array[0]
less_than_pivot = [x for x in array if x <= pivot]
more_than_pivot = [x for x in array if x > pivot]
return quick_sort(less_than_pivot) + [pivot] + quick_sort(more_than_pivot)
这段代码最关键的是pivot这个参数，这段代码里取序列的第一个元素，然后以这个元素为分组的基准，利用列表解析式使得它左边的值都比它小，右边的值都比它大。然后再分别对这些序列进行递归排序。
这段代码虽然短小利于理解，但是其效率很低，主要体现在以下方面：
- 分组基准的选取过于随便，不一定可以取到列表的中间值
- 空间复杂度大，使用了两个列表解析式，而且每次选取进行比较时需要遍历整个序列。
- 若序列长度过于小(比如只有几个元素)，快排效率就不如插入排序了。
- 递归影响性能，最好进行优化。
（2）C语言风格实现
下面用Python写一个C风格的快排(这里可以体会到快排的精髓)：
方法一（交换策略直观）：
假设对以下10个数进行快速排序：
我们先模拟快速排序的过程：首先，在这个序列中随便找一个数作为基准数，通常为了方便，以第一个数作为基准数。
在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位置，假设这个位置是 k k k。现在就需要寻找这个 k k k，并且以第 k k k 位为分界点，左边的数都 ≤ ≤ ≤ 6，右边的数都 ≥ ≥ ≥ 6。那么如何找到这个位置 k k k 呢？
我们要知道，快速排序其实是冒泡排序的一种改进，冒泡排序每次对相邻的两个数进行比较，这显然是一种比较浪费时间的。
而快速排序是分别从两端开始”探测”的，先从右往左找一个小于6的数，再从左往右找一个大于6的数，然后交换他们。这里可以用两个变量 i i i 和 j j j，分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵 i i i 和“哨兵 j j j 。刚开始的时候让哨兵 i i i 指向序列的最左边，指向数字6。让哨兵 j j j 指向序列的最右边，指向数字8。
首先哨兵 j j j 开始出动。因为此处设置的基准数是最左边的数，所以需要让哨兵 j j j 先出动，这一点非常重要。哨兵 j j j 一步一步地向左挪动（即 j = j − 1 j=j−1 j=j−1），直到找到一个小于6的数停下来。接下来哨兵 i i i 再一步一步向右挪动（即 i = i + 1 i=i+1 i=i+1），直到找到一个数大于6的数停下来。最后哨兵 j j j 停在了数字5面前，哨兵 i i i 停在了数字7面前。
现在交换哨兵 i i i 和哨兵 j j j 所指向的元素的值。交换之后的序列如下。
到此，第一次交换结束。接下来开始哨兵 j j j 继续向左挪动（再友情提醒，每次必须是哨兵j先出发）。他发现了 4 < 6 4<6 4<6 ，停下来。哨兵 i i i 也继续向右挪动的，他发现了 9 > 6 9>6 9>6，停下来。此时再次进行交换，交换之后的序列如下。
第二次交换结束。哨兵 j j j 继续向左挪动，他发现了 3 < 6 3<6 3<6 ，又停下来。哨兵 i i i 继续向右移动，此时哨兵 i i i 和哨兵 j j j 相遇了，哨兵 i i i 和哨兵 j j j 都走到 3 面前。说明此时“探测”结束。我们将基准数 6 和 3 进行交换。交换之后的序列如下。
到此第一轮“探测”真正结束。现在基准数6已经归位，此时以基准数 6 为分界点， 6 左边的数都小于等于 6 ， 6 右边的数都大于等于 6 。回顾一下刚才的过程，其实哨兵 j j j 的使命就是要找小于基准数的数，而哨兵 i i i 的使命就是要找大于基准数的数，直到 i i i 和 j j j 碰头为止。
现在我们将第一轮“探测"结束后的序列，以 6 为分界点拆分成两个序列，左边的序列是“3 1 2 5 4”，右边的序列是“9 7 10 8”。接下来还需要分别处理这两个序列。因为 6 左边和右边的序列目前都还是很混乱的。不过不要紧，我们已经掌握了方法，接下来只要模拟刚才的方法分别处理 6 左边和右边的序列即可。现在先来处理 6 左边的序列现吧。
重复第一轮的过程，应该得到如下序列：
OK，现在3已经归位。接下来需要处理3左边的序列：
处理之后，2已经归位，序列“1”只有一个数，也不需要进行任何处理，因此“1”也归位。
对于基数右边的序列，采用和左边相同的过程；最终将会得到这样的序列，如下。
细心的同学可能已经发现，快速排序的每一轮处理其实就是将这一轮的基准数归位，直到所有的数都归位为止，排序就结束了。接下来用图示的方法来展示完整的过程：
快速排序之所以比较快，是因为与冒泡排序相比，每次的交换时跳跃式的，每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O( n 2 n^2 n2) ，它的平均时间复杂度为O( n l o g 2 n nlog_2n nlog2n)。
import java.util.Arrays;
public class QuickSort {
public static void Quick_Sort(int[] arr, int begin, int end){
if(begin > end)
return;
int tmp = arr[begin];
int i = begin;
int j = end;
while(i != j){
while(arr[j] >= tmp && j > i)
j--;
while(arr[i] <= tmp && j > i)
i++;
if(j > i){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
arr[begin] = arr[i];
arr[i] = tmp;
Quick_Sort(arr, begin, i-1);
Quick_Sort(arr, i+1, end);
}
public static void main(String[] args) {
int[] test = new int[]{5, 3, 6, 4, 2, 1, 8};
QuickSort.Quick_Sort(test,0,test.length -1);
System.out.println(Arrays.toString(test));
}
}
方法二（交换策略不直观）：
def quick_sort(L):
return q_sort(L, 0, len(L) - 1)
def q_sort(L, left, right):
if left < right:
pivot = Partition(L, left, right)
q_sort(L, left, pivot - 1)
q_sort(L, pivot + 1, right)
return L
def Partition(L, left, right):
pivotkey = L[left]
while left < right:
while left < right and L[right] >= pivotkey:
right -= 1
L[left] = L[right]
while left < right and L[left] <= pivotkey:
left += 1
L[right] = L[left]
L[left] = pivotkey
return left
L = [5, 9, 1, 11, 6, 7, 2, 4]
print quick_sort(L)
快速排序需要提供三个参数：待排序序列 、序列最小下标值left、序列最大下标值right。让用户提供这三个参数很麻烦。这里写个函数进行封装：
def quick_sort(L):
return q_sort(L, 0, len(L) - 1)
下面看一下q_sort函数：
def q_sort(L, left, right):
if left < right:
pivot = Partition(L, left, right)
q_sort(L, left, pivot - 1)
q_sort(L, pivot + 1, right)
return L
这个函数的核心是pivot = Partition(L, left, right)，在执行它之前，列表的值为[5, 9, 1, 11, 6, 7, 2, 4]，而Partition函数做的事情是找到一个分组标准，然后进行分组，让它左边的值比它小，右边的值比它大。
在经过Partition函数分组后，列表变为[4, 2, 1, 5, 6, 7, 11, 9]，并把5的下标值(也就是3)返回给pivot，此时列表变成两个小列表[4, 2, 1]和[5, 6, 7, 11, 9] ，之后调用q_sort，就是调用q_sort(L,0, 2)和q_sort(L, 4 ,7)，对其进行Partition操作，直到整个列表有序为止。
下面看看关键的Partition函数是如何做的：
def Partition(L, left, right):
pivotkey = L[left]
while left < right:
while left < right and L[right] >= pivotkey:
right -= 1
L[left] = L[right]
while left < right and L[left] <= pivotkey:
left += 1
L[right] = L[left]
L[left] = pivotkey
return left
以一趟排序为例[5, 9, 1, 11, 6, 7, 2, 4]：
- 开始排序时，left=0，right=7，首先用表的第一个下标值作为 分组关键字pivot，
- 进行
while left < right and L[right] >= pivotkey:判断，其中L[right]=4 不满足条件，跳出循环，执行L[left] = L[right]，执行后列表变成：
- 然后进行
while left < right and L[left] <= pivotkey:，L[left] = 4 <= 5，条件成立，left向右边移动，然后L[left] = 9 不满足条件，执行L[right] = L[left]，执行后列表变为
- 然后进行
while left < right判断，条件成立，继续进行判断while left < right and L[right] >= pivotkey:，L[right] = 9，满足条件，right向左移动1，继续判断，不满足条件，执行L[left] = L[right]，执行后列表变为：
然后进行while left < right and L[left] <= pivotkey:判断，L[left] = 2,满足条件，left向右移动，然后L[left] = 1，满足条件，left向右移动，L[left] = 11，不满足条件，执行L[right] = L[left]，执行后列表变为：
然后进行while left < right 判断，条件成立，继续进行判断：while left < right and L[right] >= pivotkey:，满足条件，right向左移动，一直移动到这样的状态：
此时不满足条件：left < right，跳出循环。然后执行L[left] = pivotkey，并返回left下标值。此时序列变为:
接下来就是用递归分别对子列表进行排序。读者可以自己试试
问题的优化
-
分组基准
对于上面的代码，分组基准的选取只是取列表的第一个值，太过于随便，当取到序列的中间值时，快排效率是最高的，第一个值未必是列表的中间值。为了解决这个问题，我们可以选取列表中的几个值进行简单的比较，然后取这几个值的中间值 作为分组基准。 这里就不写代码了，读者可以自己实现。 -
空间使用大。
上面的代码已经解决了比较次数的问题。 -
若序列长度过于小(比如只有几个元素)，快排效率就不如插入排序了。
我们可以设置一个列表元素大小的临界值，若小于这个值，就用插入排序，大于这个值用快排。
参考
https://blog.csdn.net/qq_40941722/article/details/94396010
https://www.jianshu.com/p/2b2f1f79984e