随时要手撕的七种排序算法

# 1. 快排
def qsort(arr):
    def sort(arr, start, end):
        if start >= end: return
        i, j = start, end
        key = arr[start]
        while i < j:
            # 从右边找起
            while i < j and arr[j] >= key: j -= 1
            arr[i] = arr[j]
            while i < j and arr[i] <= key: i += 1
            arr[j] = arr[i]
        arr[i] = key
        sort(arr, start, i - 1)
        sort(arr, i + 1, end)

    sort(arr, 0, len(arr) - 1)
    return arr


# 2. 堆排序
def hsort(arr):
    def heapAdjust(arr, start, end):
        dad, son = start, 2 * start + 1
        while son <= end:
            if son + 1 <= end and arr[son] < arr[son + 1]: son += 1
            if arr[dad] < arr[son]: arr[dad], arr[son] = arr[son], arr[dad]
            dad, son = son, 2 * son + 1

    for i in range(len(arr) // 2 - 1, -1, -1):
        heapAdjust(arr, i, len(arr) - 1)  # 从最右下的父节点开始
    for i in range(len(arr) - 1, -1, -1):
        arr[0], arr[i] = arr[i], arr[0]
        heapAdjust(arr, 0, i - 1)  # 剩余的n-1个
    return arr


# 3. 冒泡
def bsort(arr):
    for i in range(len(arr)):
        for j in range(1, len(arr) - i):
            if arr[j - 1] > arr[j]: arr[j - 1], arr[j] = arr[j], arr[j - 1]  # 逆序则交换
    return arr


# 4. 选择
def csort(arr):
    def argmin(arr, start):
        ind = start
        for i in range(start, len(arr)):
            if arr[i] < arr[ind]: ind = i
        return ind

    # 从后面选择一个最小的放入排序序列的第i个
    for i in range(len(arr)):
        ind = argmin(arr, i)
        arr[i], arr[ind] = arr[ind], arr[i]
    return arr


# 5. 插入
def isort(arr, start=0, delta=1):
    for i in range(start, len(arr), delta):
        key, j = arr[i], i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1], j = arr[j], j - delta
        arr[j + 1] = key
    return arr


# 6. 归并
def msort(arr):
    def merge(a, b):
        ind = len(a) + len(b) - 1
        i, j = len(a) - 1, len(b) - 1
        a = a + [0] * len(b)
        while i >= 0 and j >= 0:
            if a[i] > b[j]:
                a[ind] = a[i]
                ind, i = ind - 1, i - 1
            else:
                a[ind] = b[j]
                ind, j = ind - 1, j - 1
        while j >= 0:
            a[ind] = a[j]
            ind, j = ind - 1, j - 1
        return a

    def sort(arr, l, r):
        if l >= r: return [arr[l]]
        mid = l + (r - l) // 2
        # 递归归并左边的和右边的, 再合并起来
        return merge(sort(arr, l, mid), sort(arr, mid + 1, r))

    return sort(arr, 0, len(arr) - 1)


# 7. 希尔
def ssort(arr):
    d = len(arr) // 2
    while d >= 2:
        for i in range(d):
            # 根据某一增量进行插入排序
            isort(arr, i, d)
        d //= 2
    return arr


import random

arr = [random.randint(0, 100) for i in range(100)]
print(bsort(arr))
print(csort(arr))
print(isort(arr))
print(ssort(arr))
print(qsort(arr))
print(msort(arr))
print(hsort(arr))