[排序N大件之]快速排序

快速排序，我好像暂时只会双指针交换法，那种挖坑填数法晚点再研究吧。

本质也是分治+递归，这里分治是相对于一个分裂点

因此，快速排序的步骤要比归并排序多一个：分拣

先分拣，在分裂，递归的调用重复这样一个过程

 

代码如下：

def quickSort(nums):
    # 递归调用自身进行分裂的函数，需要传入分裂的起始和结束位置
    quickSortHelper(nums, 0, len(nums) - 1)
    return nums

def quickSortHelper(nums, first, last):

    if first < last:
        # 找一个分裂点，并完成分拣
        split_point = partition(nums, first, last)
        # 调用自身进行排序
        quickSortHelper(nums, first, split_point)
        quickSortHelper(nums, split_point + 1, last)

def partition(nums, first, last):
    
    # 找一个基准点，定义两个指针
    pivot = nums[first]
    left = first + 1
    right = last
    
    # 一个判断分拣有没有完成的flag，并去分拣
    done = False
    while not done:
        while nums[left] <= pivot and left <= right:
            left = left + 1
        while nums[right] >= pivot and left <= right:
            right = right - 1

        if left > right:
            done = True
        else:
            temp = nums[left]
            nums[left] = nums[right]
            nums[right] = temp
    
    # 当分拣完成后，让基准点去他应该去的位置
    temp = nums[first]
    nums[first] = nums[right]
    nums[right] = temp
    
    # 把分裂点返回给递归函数，让他去调用自身
    return right

if __name__ == "__main__":
    numbers = [4, 5, 3, 6, 8, 7, 2, 9]
    print(quickSort(numbers))

 

时间复杂度：O(nlogn)，但是在极端情况下会退化为O(n²)

空间复杂度：O(logn)

且快速排序是一种不稳定的排序