十大排序

# 冒泡排序
def mp_sort(li: list):
    slen = len(li)
    for i in range(slen - 1):
        for j in range(slen - i - 1):
            if li[j] > li[j + 1]:
                li[j], li[j + 1] = li[j + 1], li[j]


# 选择排序
def xz_sort(li: list):
    slen = len(li)
    for i in range(slen - 1):
        temp = i
        for j in range(i + 1, slen):
            if li[temp] > li[j]:
                temp = j
        li[i], li[temp] = li[temp], li[i]


# 插入排序
def cr_sort(li: list):
    slen = len(li)
    for i in range(1, slen):
        temp = li[i]
        j = i - 1
        while temp < li[j] and j >= 0:
            li[j + 1] = li[j]
            j -= 1
        li[j + 1] = temp


# 快速排序
def quick_sort(li: list, left, right):
    if left < right:
        mid = partition(li, left, right)
        quick_sort(li, left, mid - 1)
        quick_sort(li, mid + 1, right)


def partition(li: list, left, right):
    temp = li[left]
    while left < right:
        # 从右往左开始找
        while left < right and temp <= li[right]:
            right -= 1
        li[left] = li[right]
        # 从左往右开始找
        while left < right and temp > li[left]:
            left += 1
        li[right] = li[left]
    li[left] = temp
    return left


# 堆排序
def sift(li, low, high):
    i = low
    j = i * 2 + 1
    temp = li[i]
    while j <= high:
        if j + 1 <= high and li[j] < li[j + 1]:
            j = j + 1
        if temp < li[j]:
            li[i] = li[j]
            i = j
            j = i * 2 + 1
        else:
            break
    li[i] = temp


def heap_sort(li):
    # 建堆,从二叉树最后开始往左 -- 往上
    for i in range(len(li) // 2 - 1, -1, -1):
        sift(li, i, len(li) - 1)
    # print(li)
    # 将根元素放到最后
    for i in range(len(li) - 1, -1, -1):
        li[0], li[i] = li[i], li[0]
        sift(li, 0, i - 1)
    # print(li)


def heapq_sort(li):
    temp = []
    import heapq
    heapq.heapify(li)
    for i in range(len(li)):
        temp.append(heapq.heappop(li))
    li.extend(temp)


# 归并排序: 基础方法 -- 合并2个有序列表，再递归合并无序列表
def merge(li: list, low, mid, high):
    if low == high:
        return
    i = low
    j = mid + 1
    temp = []
    while i <= mid and j <= high:
        if li[i] < li[j]:
            temp.append(li[i])
            i += 1
        else:
            temp.append(li[j])
            j += 1
    while i <= mid:
        temp.append(li[i])
        i += 1
    while j <= high:
        temp.append(li[j])
        j += 1
    li[low:high + 1] = temp
    # print(temp)


def merge_sort(li, left, right):
    if left < right:
        mid = (left + right) // 2
        merge_sort(li, left, mid)
        merge_sort(li, mid + 1, right)
        merge(li, left, mid, right)


# 希尔排序
def cr_sort_gap(li: list, gap: int):
    for i in range(gap, len(li)):
        temp = li[i]
        j = i - gap
        while j >= 0 and temp < li[j]:
            li[j + gap] = li[j]
            j -= gap
        li[j + gap] = temp


def shell_sort(li: list):
    d = len(li) // 2
    while d > 0:
        cr_sort_gap(li, d)
        d //= 2


# 计数排序,统计每个数出现的次数
def count_sort(li: list, max_num):
    count = [0 for i in range(max_num + 1)]
    for i in range(len(li)):
        count[i] += 1
    li.clear()
    for index, val in enumerate(count):
        while val > 0:
            li.append(index)
            val -= 1


# 桶排序
def bucket_sort(li: list, buc=100, max_num=10000):
    buckets = [[] for i in range(buc)]
    for val in li:
        buc_num = min(val // (max_num // buc), buc - 1)
        buckets[buc_num].append(val)
        # 对桶内元素进行插入排序
        for j in range(len(buckets[buc_num]) - 1, 0, -1):
            if val > buckets[buc_num][j]:
                buckets[buc_num][j + 1] = buckets[buc_num][j]
            else:
                buckets[buc_num][j + 1] = val
                break
    # 数据写回li
    li.clear()
    for i in range(buc):
        li.extend(buckets[i])


# 基数排序
def base_sort(li: list):
    max_num = max(li)
    lt = 0
    while 10 ** lt <= max_num:
        buckets = [[] for _ in range(10)]
        # 分桶
        for val in li:
            buckets[val//10**lt%10].append(val)
        # 出桶
        li.clear()
        for buc in buckets:
            li.extend(buc)
        lt += 1



import random

if __name__ == '__main__':
    li = [x for x in range(100)]
    random.shuffle(li)
    print(li)
    # mp_sort(li)
    # xz_sort(li)
    # cr_sort(li)
    # quick_sort(li, 0, len(li) - 1)
    # heap_sort(li)
    # heapq_sort(li)
    # merge_sort(li, 0, len(li) - 1)
    # shell_sort(li)
    # count_sort(li,9)
    # bucket_sort(li, 10, 10)
    base_sort(li)
    print(li)