全文一览

一、排序算法
二、完整代码

一、排序算法

本文介绍了十种最常见的排序算法：选择排序、冒泡排序、插入排序、归并排序、桶排序、计数排序、基数排序、（随机）快速排序、希尔排序和堆排序算法。

1.1 选择排序

每轮循环，从剩余数队列中选出最小的放在剩余队列最前面（或从剩余数队列中选出最大的放在剩余队列最后面，下不赘述）：

# 选择排序
def SelectionSort(l: list):
    for i in range(len(l) - 1):
        mini = i
        for j in range(i + 1, len(l)):
            if l[j] < l[mini]:
                mini = j
        if mini != i:
            l[i], l[mini] = l[mini], l[i]

1.2 冒泡排序

每轮循环中，将未排序的数列逐一跟后面的一个数进行比较，得到较大的数放在后面：

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

1.3 插入排序

插入排序算法可以直接在原列表上进行修改，在已排序好的数列里面依次向后移动数字，直到可以存放新加入的数据：

# 插入排序
def InsertionSort(L: list):
    for i in range(1, len(L)):
        if L[i] < L[i - 1]:
            j = i - 1
            tmp = L[i]
            while j >= 0:
                if L[j] > tmp:
                    L[j + 1] = L[j]
                    j -= 1
                else:
                    break
            L[j + 1] = tmp

1.4 归并排序

在归并排序中，我们使用到两个子函数 MergeRecursion 和 Merge。
MergeRecursion 用于递归地将数列拆分为两列，直到每一列都只有一个元素（此时可认为数列有序），然后调用 Merge 将两个有序列表合并为一个有序列表。

# 归并排序
# 直接调用 MergeRecursion 函数，传入列表的首尾序列
def MergeSort(L: list):
    MergeRecursion(L, 0, len(L) - 1)


# 对列表进行二分拆分成有序的原子序列，然后调用 Merge 函数进行合并
def MergeRecursion(L: list, start, end):
    if start == end:
        return
    mid = (start + end) // 2
    MergeRecursion(L, start, mid)
    MergeRecursion(L, mid + 1, end)
    Merge(L, start, mid, end)


# 将两个有序的列表 L[start:mid] 和 L[mid+1:end] 融合成一个有序列表
def Merge(L: list, start, mid, end):
    new = []
    l = start
    r = mid + 1
    while l <= mid and r <= end:
        if L[l] <= L[r]:
            new.append(L[l])
            l += 1
        else:
            new.append(L[r])
            r += 1
    if l == mid + 1:
        new.extend(L[r:end + 1])
    else:
        new.extend(L[l:mid + 1])
    L[start:end + 1] = new[:]

1.5 桶排序

桶排序是将数据先存放到不同的桶中，桶的数量 bucket_count 可以自行设定。桶内排序需要调用其他排序算法（如选择排序 SelectionSort）来实现。

# 桶排序排序
def BucketSort(L:list):
    bucket_count = 3
    Buckets = [[] for i in range(bucket_count)]
    mini = min(L)
    maxi = max(L)
    length = (maxi - mini + bucket_count) // bucket_count

    for num in L:
        index = (num - mini) // length
        Buckets[int(index)].append(num)

    for bucket in Buckets:
        SelectionSort(bucket)

    sorted_buckets = [i for bucket in Buckets for i in bucket]
    L[:] = sorted_buckets[:]

算法用到生成式对代码进行了简化。

1.6 计数排序

计数排序使用一个新的列表记录在最小值 mini 到最大值 maxi 区间内各个数字出现的次数，再通过计数还原成有序的数列。
显然，这类方法适用于整型、密集分布的数据的排序。

# 计数排序
def CountingSort(L: list):
    mini = min(L)
    maxi = max(L)
    new = [0 for i in range(mini, maxi + 1)]
    for num in L:
        new[num - mini] += 1
    # index = 0
    # for i in range(len(new)):
    #     while new[i] > 0:
    #         L[index] = mini + i
    #         index += 1
    #         new[i] -= 1
    L[:] = [mini + i for i in range(len(new)) for j in range(new[i])]

这里再次用到生成式对注释部分进行了简化。

1.7 基数排序

基数排序本质上也是一种桶排序，根据位数划分为 0~9 十个桶，再根据个十百千万等位数分别进行排序。
此方法适用于整型数据的排序。
在有负数时，可以先统一减去最小的负数进行排序，事后再统一加回来。

# 基数排序
def RadixSort(L: list):
    base = 1
    maxi = max(L)
    while base < maxi:
        Buckets = [[] for i in range(10)]
        for num in L:
            index = num // base % 10
            Buckets[index].append(num)
        # i = 0
        # for bucket in Buckets:
        #     for num in bucket:
        #         L[i] = num
        #         i += 1
        L[:] = [num for bucket in Buckets for num in bucket]
        base *= 10

这里再一次用到生成式。

1.8 快速排序

快速排序算法使用数列的第一个数作为基准 pivot，将大于它的数和小于它的数分别放在它的两边；然后对两边的数列递归使用上述操作，直到每个数都做过基准。
与归并排序类似，QuickSort 传入待处理列表；QuickRecursion 实现递归拆分；QuickSortPivot 则实现具体每一步中如何拆分数据，并返回基准数应在的位置（用于递归拆分）。

# 快速排序算法
def QuickSort(L: list):
    QuickRecursion(L, 0, len(L) - 1)


def QuickRecursion(L: list, start, end):
    if start >= end:
        return
    pivot = QuickSortPivot(L, start, end)
    QuickRecursion(L, start, pivot - 1)
    QuickRecursion(L, pivot + 1, end)


def QuickSortPivot(L: list, start, end):
    pivot = start
    j = start + 1
    for i in range(start + 1, end + 1):
        if L[i] < L[pivot]:
            L[i], L[j] = L[j], L[i]
            j += 1
    L[pivot], L[j - 1] = L[j - 1], L[pivot]
    pivot = j - 1
    return pivot

随机快速排序算法跟快速排序算法大体类似，区别在于 RandomQuickSortPivot 函数相比 QuickSortPivot 函数，在前两行增加了随机数，使得每次选定的基准为随机的。

# 随机快速排序
def RandomQuickSort(L: list):
    RandomQuickRecursion(L, 0, len(L) - 1)


def RandomQuickRecursion(L: list, start, end):
    if start >= end:
        return
    pivot = RandomQuickSortPivot(L, start, end)
    RandomQuickRecursion(L, start, pivot - 1)
    RandomQuickRecursion(L, pivot + 1, end)


def RandomQuickSortPivot(L: list, start, end):
    import random
    randIndex = random.randint(start, end)
    L[start], L[randIndex] = L[randIndex], L[start]
    pivot = start
    j = start + 1
    for i in range(start + 1, end + 1):
        if L[i] < L[pivot]:
            L[i], L[j] = L[j], L[i]
            j += 1
    L[pivot], L[j - 1] = L[j - 1], L[pivot]
    pivot = j - 1
    return pivot

1.9 希尔排序

希尔排序是一种改进后的插入排序。
希尔排序将数据分成 n/2 组，组内数据间隔为 n/2，然后将这些组分别进行插入排序；
之后将数据分成 n/4 组，组内数据间隔为 n/4，同上将这些组分别进行插入排序；
重复上述步骤，直到组内数据间隔不足 1，此时只剩一个组。

# 希尔排序
def ShellSort(L:list):
    n = len(L)
    gap = n // 2
    while gap > 0:
        for i in range(gap,n):
            tmp = L[i]
            j = i
            while j >= gap:
                if tmp < L[j-gap]:
                    L[j] = L[j - gap]
                else:
                    break
                j -= gap
            L[j] = tmp
        gap //= 2

1.10 堆排序

堆排序利用了二叉树的性质。通过交换节点值，可以选举出堆顶的最大元素，将其放入列表后面；再重复选举、后置，即可实现排序。
maxHeapify 函数用于选举出最大值， HeapSort 用于将最大值后置，并循环对剩余的数据进行选举、后置操作。
算法中的 heap 其实是用列表实现的。需要注意堆第一个元素开始的下标为 1，故需要在列表前填充一个元素。

# 堆排序
def HeapSort(L: list):
    heap = [None] + L  # heap 从 1 开始遍历，list 从 0 开始遍历，通过填补实现对接
    root = 1
    for i in range(len(heap) // 2, root - 1, -1):
        maxHeapify(heap, i, len(heap) - 1)
    for i in range(len(heap) - 1, root, -1):
        heap[i], heap[root] = heap[root], heap[i]
        maxHeapify(heap, root, i - 1)
    L[:] = heap[root:]


def maxHeapify(heap: list, start, end):
    son = start * 2
    while son <= end:
        if son + 1 < end and heap[son + 1] > heap[son]:
            son += 1
        if heap[son] > heap[start]:
            heap[start], heap[son] = heap[son], heap[start]
            start, son = son, son * 2
        else:
            break

二、完整代码

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @FileName  :sort_algorithms.py
# @Time      :2023/7/25 14:35
# @Author    :Carl.Zhang
# Function   :Eleven most used sort algorithms.

# 选择排序
def SelectionSort(L: list):
    for i in range(len(L) - 1):
        mini = i
        for j in range(i + 1, len(L)):
            if L[j] < L[mini]:
                mini = j
        if mini != i:
            L[i], L[mini] = L[mini], L[i]


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


# 插入排序
def InsertionSort(L: list):
    for i in range(1, len(L)):
        if L[i] < L[i - 1]:
            j = i - 1
            tmp = L[i]
            while j >= 0:
                if L[j] > tmp:
                    L[j + 1] = L[j]
                    j -= 1
                else:
                    break
            L[j + 1] = tmp


# 插入排序2
def InsertionSort2(L: list):
    for i in range(1, len(L)):
        if L[i] < L[i - 1]:
            for j in range(i):
                if L[i] < L[j]:
                    tmp = L[i]
                    for k in range(i, j, -1):
                        L[k] = L[k - 1]
                    L[j] = tmp
                    break


# 归并排序
# 直接调用 MergeRecursion 函数，传入列表的首尾序列
def MergeSort(L: list):
    MergeRecursion(L, 0, len(L) - 1)


# 对列表进行二分拆分成有序的原子序列，然后调用 Merge 函数进行合并
def MergeRecursion(L: list, start, end):
    if start == end:
        return
    mid = (start + end) // 2
    MergeRecursion(L, start, mid)
    MergeRecursion(L, mid + 1, end)
    Merge(L, start, mid, end)


# 将两个有序的列表 L[start:mid] 和 L[mid+1:end] 融合成一个有序列表
def Merge(L: list, start, mid, end):
    new = []
    l = start
    r = mid + 1
    while l <= mid and r <= end:
        if L[l] <= L[r]:
            new.append(L[l])
            l += 1
        else:
            new.append(L[r])
            r += 1
    if l == mid + 1:
        new.extend(L[r:end + 1])
    else:
        new.extend(L[l:mid + 1])
    L[start:end + 1] = new[:]


# 桶排序排序
def BucketSort(L: list):
    bucket_count = 3
    Buckets = [[] for i in range(bucket_count)]
    mini = min(L)
    maxi = max(L)
    length = (maxi - mini + bucket_count) // bucket_count

    for num in L:
        index = (num - mini) // length
        Buckets[int(index)].append(num)

    for bucket in Buckets:
        SelectionSort(bucket)

    sorted_buckets = [i for bucket in Buckets for i in bucket]
    L[:] = sorted_buckets[:]


# 计数排序
def CountingSort(L: list):
    mini = min(L)
    maxi = max(L)
    new = [0 for i in range(mini, maxi + 1)]
    for num in L:
        new[num - mini] += 1
    # index = 0
    # for i in range(len(new)):
    #     while new[i] > 0:
    #         L[index] = mini + i
    #         index += 1
    #         new[i] -= 1
    L[:] = [mini + i for i in range(len(new)) for j in range(new[i])]


# 基数排序
def RadixSort(L: list):
    base = 1
    maxi = max(L)
    while base < maxi:
        Buckets = [[] for i in range(10)]
        for num in L:
            index = num // base % 10
            Buckets[index].append(num)
        # i = 0
        # for bucket in Buckets:
        #     for num in bucket:
        #         L[i] = num
        #         i += 1
        L[:] = [num for bucket in Buckets for num in bucket]
        base *= 10


# 快速排序算法
def QuickSort(L: list):
    QuickRecursion(L, 0, len(L) - 1)


def QuickRecursion(L: list, start, end):
    if start >= end:
        return
    pivot = QuickSortPivot(L, start, end)
    QuickRecursion(L, start, pivot - 1)
    QuickRecursion(L, pivot + 1, end)


def QuickSortPivot(L: list, start, end):
    pivot = start
    j = start + 1
    for i in range(start + 1, end + 1):
        if L[i] < L[pivot]:
            L[i], L[j] = L[j], L[i]
            j += 1
    L[pivot], L[j - 1] = L[j - 1], L[pivot]
    pivot = j - 1
    return pivot


# 随机快速排序
def RandomQuickSort(L: list):
    RandomQuickRecursion(L, 0, len(L) - 1)


def RandomQuickRecursion(L: list, start, end):
    if start >= end:
        return
    pivot = RandomQuickSortPivot(L, start, end)
    RandomQuickRecursion(L, start, pivot - 1)
    RandomQuickRecursion(L, pivot + 1, end)


def RandomQuickSortPivot(L: list, start, end):
    import random
    randIndex = random.randint(start, end)
    L[start], L[randIndex] = L[randIndex], L[start]
    pivot = start
    j = start + 1
    for i in range(start + 1, end + 1):
        if L[i] < L[pivot]:
            L[i], L[j] = L[j], L[i]
            j += 1
    L[pivot], L[j - 1] = L[j - 1], L[pivot]
    pivot = j - 1
    return pivot


# 希尔排序
def ShellSort(L: list):
    n = len(L)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            tmp = L[i]
            j = i
            while j >= gap:
                if tmp < L[j - gap]:
                    L[j] = L[j - gap]
                else:
                    break
                j -= gap
            L[j] = tmp
        gap //= 2


# 堆排序
def HeapSort(L: list):
    heap = [None] + L  # heap 从 1 开始遍历，list 从 0 开始遍历，通过填补实现对接
    root = 1
    for i in range(len(heap) // 2, root - 1, -1):
        maxHeapify(heap, i, len(heap) - 1)
    for i in range(len(heap) - 1, root, -1):
        heap[i], heap[root] = heap[root], heap[i]
        maxHeapify(heap, root, i - 1)
    L[:] = heap[root:]


def maxHeapify(heap: list, start, end):
    son = start * 2
    while son <= end:
        if son + 1 < end and heap[son + 1] > heap[son]:
            son += 1
        if heap[son] > heap[start]:
            heap[start], heap[son] = heap[son], heap[start]
            start, son = son, son * 2
        else:
            break


if __name__ == "__main__":
    l = [34, 3, 16, 8, 2, 23, 12, 9, 21, 5]
    # SelectionSort(l)
    # BubbleSort(l)
    # InsertionSort2(l)
    # print(InsertionSort(l))
    # MergeSort(l)
    # BucketSort(l)
    # CountingSort(l)
    # RadixSort(l)
    # QuickSort(l)
    # RandomQuickSort(l)
    # ShellSort(l)
    HeapSort(l)
    print(l)

参考：@英雄哪里出来的 B站视频
更多 python 的使用方法和应用，敬请关注后续更新~

【python】十大排序算法