排序算法之快速排序举例详解-python实现3版代码及改进过程

快速排序思想步骤：

1.找到一个基准值key

2.设置2个元素下标i=0和j=len-1

3.从后往前找到比key小的数num[j]，从前往后找到比key大的数num[i]（这里有个先后顺序）

4.交换这两个数：num[i]，num[j]

5.继续重复该过程，直到i==j，完成一趟排序（循环结束条件）

6.以num[j]为界限，左右2边分别进行快速排序

图片来源于百度：

 

总结：

确定一个数字的准确位置，再递归它分出来的两个数组，直到递归规模缩小为1停止，最终整个数组会趋于有序。

注意：

i和j先后顺序不重要，但是每次都必须按照第一次的顺序来。如果第一次是i先走，后面的子分组快速排序也得i先走。

举例

num=[1，3，4，2，6，5]

1.找到基准值（首尾都行），key=1

2.num[i]=1，num[j]=5

3.j--找到比1小的第一个数

4.此时j=i（满足j<=i找不到），第一趟快速排序结束，数字1为有序。

此时顺序为：[1,3,4,2,6,5]

5.数字1左边的分组数据<=1左边分组已经有序，右边的分组继续进行快速排序

6.选择基准值key=3，num[i]=3，num[j]=5

7.j--找到比3小的第一个数，num[j]=2

8.i++找到比3大的第一个数，num[i]=4

9.交换num[i]和num[j]

此时顺序为：[1,3,2,4,6,5]

10.j--找比3小的第一个数，num[i]=2，此时j==i

11.交换key和num[j]，发现3为分界线的左边 只有1个数字：2。（子分组，1为有序了）所以只需要对3右边进行快速排序。

此时顺序为：[1,2,3,4,6,5]

12.找基准值4，num[i]=4,num[j]=5

13.j--找到比4小的第一个数，找不到，此时i=j，num[i]==num[j]==key，4为有序

此时顺序为：[1,2,3,4,6,5]

14.找到基准值6，num[i]=6，num[j]=5

15.j--找到比6小的第一个数，5

16.i++找到比6大的第一个数，找不到，此时i=j，num[i]==num[j]==5

17.交换key和num[j]

此时顺序为：[1,2,3,4,5,6]

第4步和第17步体现了i和j顺序的作用。

由于我这里是j先走，所以，num[j]往前走到i==j还是没找到比key小的数的话，说明key是有序，不用交换。---对应第4步

当j--找到了比key小的第一个数（i不等于j时）之后，i++，直到i==j都没找到比key大的数，此时交换key和num[j]。----对应第17步

代码实现：

第一版代码（存在重复元素会陷入死循环）

1.设置基准值变量key，游标i，j。i是起始索引，j是结束索引

2.通过一个partition函数去完成num[i]，num[j]的交换，函数返回索引mid，mid为划分子分组的界限

3.快速排序函数：参数为列表，开始索引，结束索引（用来传给partition函数获取mid索引）

4.以mid索引为界限，对左右两边子分组分别递归调用快速排序函数。

def partition(num,i,j):
    key=num[i]
    while i<j:
        while i<j and num[j]>key:
            j=j-1
        while i<j and num[i]<key:
            i=i+1
        num[i],num[j]=num[j],num[i]
    return j

def quick_sort(num,i,j):
    if i<j:
        mid = partition(num, i, j)
        quick_sort(num,i,mid-1)
        quick_sort(num, mid + 1, j)
# num=[1,3,4,2,6,5]
num = [5, 7, 4, 6, 3, 1, 2, 9, 8]
i=0
j=len(num)-1
quick_sort(num,i,j)
print(num)

partition函数：

1.当i小于j的时候，判断num[j]>key就一直执行j=j-1，直到找到一个num[j]<=key

2.再判断i<j并且num[i]>key，一直执行i=i+1，直到找到一个num[i]>=key

3.交换num[i]和num[j]的值

当列表内没有重复元素时，初版代码完美实现。

第二版代码（重复元素测试通过）

但是当列表中存在重复元素，会跳过partition中两个内循环，所以并不会有i和j的更改。

直接在外面的循环中一直交换2个元素，就陷入了死循环。于是，我在第一版代码的基础上又做了一些改进得到第二版代码。

思路沿用第一版，具体实现区别在于partition函数。

partition函数：

1.设置基准值key=num[i]（我设置的左边的值为基准值）

2.循环比较num[j]和key的大小，如果num[j]>=key，执行j=j-1。当num[j]<key的时候，停止循环，然后把num[j]赋值给num[i]（此时比key大的数放到左边去了）

3.循环比较num[i]和key的大小，如果num[i]<=key，执行i=i+1。当num[i]>key的时候，停止循环，把num[i]赋值给num[j]（此时比key小的数放到右边了）

4.把key的值赋值给num[i]，相当于key为中间值，第一轮结束，小的数已分到了左边，大的数分到了右边。

def partition(num,i,j):
    key=num[i]
    while i<j:
        while i<j and num[j]>=key:
            j=j-1;
        num[i]=num[j]
        while i<j and num[i]<=key:
            i=i+1
        num[j]=num[i]
    num[i]=key
    return i

def quick_sort(num,i,j):
    if i<j:
        mid = partition(num, i, j)
        quick_sort(num,i,mid-1)
        quick_sort(num, mid + 1, j)
# num=[1,3,4,2,6,5]
num=[1,0,2,2,1,0]
# num = [5, 7, 4, 6, 3, 1, 2, 9, 8]
i=0
j=len(num)-1
quick_sort(num,i,j)
print(num)

在没有重复元素的时候，2-3步相当于第一版代码的外循环里面的交换。

当有重复元素的时候，也会交换，但是不会陷入上一版代码的死循环了。

上一版代码由于没有重复元素，所以内循环里，>=和<=的效果都一样。这版代码是有重复元素的，所以得加上=。

因为如果j=j-1找到小于key的元素，就要进行交换。如果是找到相等元素，可以不进行交换。