python归并排序、快速排序

归并排序（Merge Sort）

归并排序把数组从中间分成前后两部分,重复拆分直至最小粒度,然后对前后两部分分别排序,再把排序好的两部分合并在一起.
递推公式:merge_sort(start, end)=merge(merge_sort(start, mid), merge_sort(mid+1, end))
终止条件:start >= end

def merge_sort(array, start, end):
    """终止条件"""
    if start >= end:
        return
    mid = int((start+end)/2)
    #递推公式
    merge_sort(array, start, mid)
    merge_sort(array, mid+1, end)
    merge(array, start, mid, end)


def merge(array, start, mid, end):
    temp = []
    p1 = start
    p2 = mid+1
    while p1 <= mid and p2 <= end:
        if array[p1] <= array[p2]:
            temp.append(array[p1])
            p1 += 1
        else:
            temp.append(array[p2])
            p2 += 1
    while p1 <= mid:
        temp.append(array[p1])
        p1 += 1
    while p2 <= end:
        temp.append(array[p2])
        p2 += 1

    for i in range(0,len(temp)):
        array[i+start] = temp[i]


if __name__ == '__main__':
    a = [2, 5, 3, 6, 1, 4]
    b = [1, 2, 3, 4, 5, 6]
    merge_sort(a, 0, len(a)-1)
    merge_sort(b, 0, len(b)-1)
    print(a)
    print(b)

快速排序（Quick Sort）

快排在数组中选择任意一个下标点作为pivot(分区点),遍历start到end之间的数据,
将小于pivot的放左边,将大于pivot的放右边,再重复处理小于区和大于区,直至满足终止条件
递推公式:quick_sort(start, end) = quick_sort(start, pivot-1) + quick_sort(pivot+1, end)
终止条件:start >= end

def quick_sort(array, start, end):
    if start >= end:
        return
    pivot = partition(array, start, end)
    quick_sort(array, start, pivot-1)
    quick_sort(array, pivot+1, end)


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


if __name__ == '__main__':
    a = [2, 5, 3, 6, 1, 4]
    b = [1, 2, 3, 4, 5, 6]
    quick_sort(a, 0, len(a)-1)
    quick_sort(b, 0, len(b)-1)
    print(a)
    print(b)

图解，复杂度、稳定性

	平均时间复杂度	最坏时间复杂度	空间复杂度	原地排序	稳定排序
归并排序(Merge Sort)	O(nlogn)	O(n²)	O(n)	否	是
快速排序(Quick Sort)	O(nlogn)	O(n²)	O(1)	是	否

递归排序和快速排序都是是分治思想(分而治之,将大问题分解成小的子问题,小的子问题解决了,大的问题也就解决了),
递归排序是由上到下,再由下到上,先分解为最小粒度,再由下到上,依次处理子问题,合并
快速排序是由上到下,先分区再处理子问题