排序算法之快速排序

快速排序

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

数据结构标准快排

def quick_sort(nums, left, right):
    if left < right:
        pivot = partition(nums, left, right)
        quick_sort(nums, left, pivot - 1)
        quick_sort(nums, pivot + 1, right)

def partition(nums, left, right):
    pivot = nums[left]
    while left < right:
        while left < right and nums[right] >= pivot:
            right -= 1
        nums[left], nums[right] = nums[right], nums[left]
        while left < right and nums[left] <= pivot:
            left += 1
        nums[left], nums[right] = nums[right], nums[left]
    return left

第一种改版

def quick_sort(array, left, right):
    if left<right:
        q = partition(array, left, right)
        quick_sort(array, left, q-1)
        quick_sort(array, q+1, right)
        
def partition(array, left, right):
    x = array[right]
    i = left - 1
    for j in range(left, right):
        if array[j] <= x:
            i += 1
            array[i], array[j] = array[j], array[i]
    array[i+1], array[right] = array[right], array[i+1]
    return i+1

第二种改版

def quick_sort(nums, start, end):
    if start>=end:
        return
    left = start
    right = end
    mid = int((left+right)/2)
    pivot = nums[mid]
    while left<=right:
        while left<=right and nums[left]<pivot:
            left += 1
        while left<=right and nums[right]>pivot:
            right -= 1
        if left<=right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1
    quick_sort(nums, start, right)
    quick_sort(nums, left, end)

arr = [1,4,6,3,2]
quick_sort(arr, 0, len(arr)-1)
print(arr)

时间复杂度

最优的情况下时间复杂度为：O( nlogn )，每一次取到的元素都刚好平分整个数组
最差的情况下时间复杂度为：O( n^2 )，每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序了
平均时间复杂度也是：O(nlogn)

空间复杂度

就地快速排序使用的空间是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据；
最优的情况下空间复杂度为：O(logn) ；每一次都平分数组的情况
最差的情况下空间复杂度为：O( n ) ；退化为冒泡排序的情况

不稳定