常见排序的Python实现

# 常用八大排序算法：插入（直接插入，shell）、选择（简单选择，堆排序）、交换（冒泡，快速排序）、归并排序和基数排序；


# 直接插入排序
def insert_sort(lst):
    l = len(lst)
    for i in range(1, l):
        j = i - 1
        while j >= 0 and lst[j+1] < lst[j]:
            lst[j+1], lst[j] = lst[j], lst[j+1]
            j -= 1
    return lst


# shell排序
def shell_sort(lst):
    le = len(lst)
    step = le // 2
    while step > 0:
        for i in range(step):  # 总共有几组；
            j = i
            while j + step < le:  # 每组中执行直接插入算法；
                if lst[j+step] < lst[j]:
                    lst[j+step], lst[j] = lst[j], lst[j+step]
                j += step
        step //= 2  # 缩小相邻比较元素的间距。
    return lst


# 简单选择排序
def select_sort(lst):
    le = len(lst)
    for i in range(le):
        min_idx = i
        for j in range(i, le):
            if lst[min_idx] > lst[j]:
                min_idx = j
        lst[min_idx], lst[i] = lst[i], lst[min_idx]
    return lst


# 堆排序
def heap_sort(lst):
    le = len(lst)
    for i in range(le-1, 0, -1):  # 构建大顶堆；
        if lst[i] > lst[(i-1)//2]:
            lst[i], lst[(i-1)//2] = lst[(i-1)//2], lst[i]
    m = le - 1
    while m > 0:  # 依次将首元素（最大值）和最后元素替换，然后调整未排序列表为大顶堆；
        lst[m], lst[0] = lst[0], lst[m]
        n = 0
        while 2 * n + 1 < m:
            min_idx = 2 * n + 1
            while 2 * n + 2 < m and lst[min_idx] < lst[2 * n + 2]:
                min_idx = 2 * n + 2
            lst[n], lst[min_idx] = lst[min_idx], lst[n]
            n = min_idx
        m -= 1
    return lst


# 冒泡排序
def bubble_sort(lst):
    le = len(lst)
    for i in range(0, le):
        mark = False
        k = le - 1
        while k > i:
            if lst[k] < lst[k-1]:
                lst[k], lst[k-1] = lst[k-1], lst[k]
                mark = True
            k -= 1
        if not mark:
            break
    return lst


# 快速排序算法(递归)
def quick_sort(lst, left, right):
    le =len(lst)
    if left >= right:
        return lst
    key = lst[left]
    low = left
    high = right
    while low < high:
        while low < high and lst[high] > key:
            high -= 1
        lst[low] = lst[high]
        while low < high and lst[low] < key:
            low += 1
        lst[high] = lst[low]
    lst[low] = key
    quick_sort(lst, left, low-1)
    quick_sort(lst, low+1, right)
    return lst


# 归并排序
def merge_sort(lst):
    le = len(lst)
    if le <= 1:
        return lst
    mid = le//2
    left = merge_sort(lst[:mid])
    right = merge_sort(lst[mid:])
    return merge(left, right)


def merge(left, right):
    m, n = len(left), len(right)
    i, j = 0, 0
    result = []
    while i < m and j < n:
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result += left[i:]
    result += right[j:]
    return result


# 基数排序(桶排序)
def radix_sort(lists, d):
    for i in range(d):
        s = [[] for i in range(10)]
        for j in lists:
            s[j//(10**i)%10].append(j)
        lists = [j for i in s for j in i]   #把所有元素遍历出来
    return lists