排序算法专题-快速排序

  快速排序是冒泡排序算法基础上改进的进阶版排序算法，他使用分治法把一个序列基于一个基准分成两个子序列，比如left均小于基准,right均大于基准，通过再次选择基准对left和right序列进行递归的划分，直到划分的数组长度为1或者0，由于划分依据是在序列中选择一个基准，即每次迭代至少有一个元素（基准）是放到了正确的而位置，所以这个算法一定会结束。

• 算法步骤：
  1：从数列中挑出一个元素，称为 “基准”（pivot）;
  2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

  大致过程如下图：

图片来源：图解快速排序算法
  实际过程中，对基准的选择一般是选择该序列最左边的值作为基准，我们对上述过程进行分析，来理清一下，如何用代码来实现快速排序算法。可以参考归并排序的思路，（排序算法专题-归并排序），快速排序的步骤分为：第一步，选择基准，第二步，基于基准调整数组，将数组分为两个序列left和right，left均小于基准，right均大于基准，记录基准最后的位置，第三步，选择left和right最左边的数值作为基准，重复第二步、第三步，直到最后得到的序列长度为1或者0。到这里思路就出来了，第一个方法：基于基准将序列划分为left和right序列，返回基准最后的位置；第二个方法：基于基准最后的位置，对两个子序列left和right数组进行再一次划分，直到直到最后得到的序列长度为1或者0。所以方法二是递归函数，方法一是重排函数。

• 我们从最简单的功能开始实现，即第二个方法，给定一个数组、left、right,将nums[left:right+1]区间内的数组进行划分，并返回nums[left]最后的索引位置，注意这里我们不是用交换，而是直接用赋值，避免了很多不必要的交换步骤。代码如下：

def partition(nums, left, right):
    """
    nums[left:right+1]区间内的数组基于nums[left]的值进行划分
    >>>partition([3,38, 5, 44, 15, 36]  , 1, 5)
    >>>4
    >>>[3, 36, 5, 15, 38, 44]
    """
    datum = nums[left]
    while left < right:
        while left < right and datum <= nums[right]:
            right -= 1
        nums[left] = nums[right]
        while left < right and datum >= nums[left]:
            left += 1
        nums[right] = nums[left]
    nums[left] = datum
    print(nums)
    return left

• 最后我们再来解决递归方法，首先我们可以通过partition函数发现，递归的参数必然有nums, left, right，而且是用partition方法返回的基准位置索引来更新left或者right，现在思考我们还需不需要加参数，答案是不用了。我们现在考虑一种特殊情况，当我们最后输入的数组是[3]，这个时候left=right=0，该序列是有序的，因此我们的跳出条件是left >= right，到这里我们就可以开始写递归方法了，代码如下。

def quickSort(nums, left, right):
    """
    快速排序，nums为待排序数组，left、right为数组左端和右端的索引
    >>>quickSort([3, 5, 15, 36, 38, 44], 0, 5)
    >>>[3, 5, 15, 36, 38, 44]
    """
    if left < right:
        partitionIndex = partition(nums, left, right)
        quickSort(nums, left, partitionIndex-1)
        quickSort(nums, partitionIndex+1, right)
    return nums

• 每一次迭代都可以确定一个基准的最终位置，因此每次迭代后都不需要再管那些基准们了。总代码如下：

def quickSort(nums, left, right):
    """
    快速排序，nums为待排序数组，left、right为数组左端和右端的索引
    >>>quickSort([3, 5, 15, 36, 38, 44], 0, 5)
    >>>[3, 5, 15, 36, 38, 44]
    """
    if left < right:
        partitionIndex = partition(nums, left, right)
        quickSort(nums, left, partitionIndex-1)
        quickSort(nums, partitionIndex+1, right)
    return nums

def partition(nums, left, right):
    """
    nums[left:right+1]区间内的数组基于nums[left]的值进行划分
    >>>partition([3,38, 5, 44, 15, 36]  , 1, 5)
    >>>4
    >>>[3, 36, 5, 15, 38, 44]
    """
    datum = nums[left]
    while left < right:
        while left < right and datum <= nums[right]:
            right -= 1
        nums[left] = nums[right]
        while left < right and datum >= nums[left]:
            left += 1
        nums[right] = nums[left]
    nums[left] = datum
    print(nums)
    return left

nums = [3,38, 5, 44, 15, 36]  
left, right = 0, len(nums)-1
quickSort(nums, left, right)

• 算法解析：首先由于变换过程使用了赋值法，所有的操作都是在原数组上操作，其他的均为常数，因此空间复杂度为O(1)。时间复杂度的计算同样可以参考归并排序，分成两个部分来算，首先partition方法体内的时间复杂度肯定是n，quickSort递归方法的时间复杂度不好计算，依赖于nums，如果nums是有序数组，每次选中的基准都是最大值或者最小值，那么left:right长度之比就是1：n-1，每一次迭代只能确定一个数的位置，因此需要n-1次迭代，时间复杂度为O(n)，因此该方法最坏时间复杂度为O(n²)；如果每次的基准取到的都是中间值，那么每次序列划分得到都是均等的数组，相当于每次少一半，因此时间复杂度为O(log n)，因此该方法最好时间复杂度为O(n log n)。
• 相比于归并排序稳定的为O(n log n)时间复杂度，快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比空间复杂度等于 O(n) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。
• 稳定性分析，注意下面的代码，当与基准相等的数出现在右边是，该右边的数会赋值给左指针指向的位置，相等元素的相对位置发了变化，因此快速排序是一种不稳定的排序算法。

 while left < right and datum <= nums[right]:
            right -= 1
        nums[left] = nums[right]