【稳住，can win】Python排序

排序

排序方法	最坏时间复杂度
冒泡排序	$$O(n^2)$$
选择排序	$$O(n^2)$$
插入排序	$$O(n^2)$$
快速排序	$$O(n^2)$$
希尔排序	$$O(n^2)$$
归并排序	$$O(nlogn)$$

冒泡排序

n个数据比较n-1趟，每趟比较次数从n-1逐次减一，每趟确定一个极值。

def bubble_sort(data):
    for j in range(len(data) - 1, 0, -1):
        for i in range(j):
            if data[i] > data[i+1]:
                data[i], data[i+1] = data[i+1], data[i]

选择排序

n个数据进行n-1次比较，每次比较从当前未确定的位置到数据结束位置，确定一个数据的位置。

def select_sort(data):
    n = len(data)
    for i in range(n-1):
        min_idx = i
        for j in range(i+1, n):
            if data[j] < data[min_idx]:
                min_idx = j
        if i != min_idx:
            data[i], data[min_idx] = data[min_idx], data[i]

插入排序

顾名思义，插入排序，用一句话总结就是无序数据往有序数据里插入。

def insert_sort(data):
    for i in range(1, len(data)):
        for j in range(i, 0, -1):
            if data[j] < data[j - 1]:
                data[j], data[j - 1] = data[j - 1], data[j]

快速排序

def quick_sort(data, start, end):
    if start >= end:
        return

    mid = data[start]
    low = start
    high = end

    while low < high:
        while high > low and data[high] >= mid:
            high -= 1

        data[low] = data[high]

        while high > low and data[low] < mid:
            low += 1

        data[high] = data[low]

    data[low] = mid

    quick_sort(data, 0, low - 1)
    quick_sort(data, low + 1, end)

希尔排序

希尔排序就是在插入排序基础上，加入了步长这个概念，每次排序的元素按步长取。

def shell_sort(data):
    n = len(data)
    gap =int(n / 2)

    while gap > 0:
        for i in range(gap, n):
            j = i
            while j >= gap and data[j - gap] > data[j]:
                data[j - gap], data[j] = data[j], data[j - gap]
                j -= gap
        gap = int(gap / 2)

归并排序

def merge_sort(data):
    if len(data) <= 1:
        return data
    num = len(data) // 2
    left = merge_sort(data[:num])
    right = merge_sort(data[num:])

    return merge(left, right)

def merge(left, right):
    l, r = 0, 0
    result = []

    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1  

        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]

    return result