Python 中的“八大排序算法”通常指的是以下几种经典排序算法，每种算法都有其独特的工作原理和效率特征：

  1. 插入排序 (Insertion Sort): 插入排序的基本思想是将待排序的元素按顺序插入到已排序的部分中，保持已排序部分一直有序。适用于小规模数据或部分有序的数据。

Python

1def insertion_sort(L):
2    for i in range(1, len(L)):
3        key = L[i]
4        j = i - 1
5        while j >=0 and key < L[j]:
6            L[j + 1] = L[j]
7            j -= 1
8        L[j + 1] = key
9    return L
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  1. 选择排序 (Selection Sort): 选择排序每次从未排序的部分找出最小（或最大）的元素，放到已排序部分的末尾。

Python

1def selection_sort(L):
2    for i in range(len(L)):
3        min_index = i
4        for j in range(i+1, len(L)):
5            if L[j] < L[min_index]:
6                min_index = j
7        L[i], L[min_index] = L[min_index], L[i]
8    return L
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  1. 冒泡排序 (Bubble Sort): 冒泡排序通过不断交换相邻的两个不正确排序的元素，逐步把较大的数“冒泡”到数列的末尾。

Python

1def bubble_sort(L):
2    n = len(L)
3    for i in range(n):
4        for j in range(0, n-i-1):
5            if L[j] > L[j+1]:
6                L[j], L[j+1] = L[j+1], L[j]
7    return L
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  1. 希尔排序 (Shell Sort): 希尔排序是对插入排序的一种改进，通过比较相隔一定间隔的元素来减少交换次数，间隔序列通常是动态递减的。

Python

1def shell_sort(L):
2    gap = len(L) // 2
3    while gap > 0:
4        for i in range(gap, len(L)):
5            temp = L[i]
6            j = i
7            while j >= gap and L[j-gap] > temp:
8                L[j] = L[j-gap]
9                j -= gap
10            L[j] = temp
11        gap //= 2
12    return L
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  1. 快速排序 (Quick Sort): 快速排序是一种分治策略，它选取一个基准元素，将数组划分为两部分，使得一部分的所有元素都比另一部分的小，然后递归地对这两部分进行排序。

Python

1def quick_sort(L):
2    if len(L) <= 1:
3        return L
4    pivot = L[len(L) // 2]
5    left = [x for x in L if x < pivot]
6    middle = [x for x in L if x == pivot]
7    right = [x for x in L if x > pivot]
8    return quick_sort(left) + middle + quick_sort(right)
9
10# 或者使用更高效的in-place版本：
11def quick_sort_in_place(L, low=0, high=None):
12    if high is None:
13        high = len(L) - 1
14    if low < high:
15        pivot_index = partition(L, low, high)
16        quick_sort_in_place(L, low, pivot_index - 1)
17        quick_sort_in_place(L, pivot_index + 1, high)
18    return L
19
20def partition(L, low, high):
21    # 这里省略了具体实现，partition函数会选择基准元素并将数组分割
22    # ...
23    pass
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  1. 归并排序 (Merge Sort): 归并排序也是采用分治策略，将数组分成两半进行排序，然后再合并两个已排序的半部分。

Python

1def merge_sort(L):
2    if len(L) <= 1:
3        return L
4    mid = len(L) // 2
5    left_half = L[:mid]
6    right_half = L[mid:]
7
8    return merge(merge_sort(left_half), merge_sort(right_half))
9
10def merge(left, right):
11    merged = []
12    left_index, right_index = 0, 0
13
14    while left_index < len(left) and right_index < len(right):
15        if left[left_index] <= right[right_index]:
16            merged.append(left[left_index])
17            left_index += 1
18        else:
19            merged.append(right[right_index])
20            right_index += 1
21
22    merged.extend(left[left_index:])
23    merged.extend(right[right_index:])
24    return merged
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  1. 堆排序 (Heap Sort): 堆排序首先构造一个大顶堆（或小顶堆），然后反复将堆顶元素与最后一个元素交换，并重新调整堆，直到整个序列有序。

Python

1def heapify(arr, n, i):
2    largest = i
3    l = 2 * i + 1
4    r = 2 * i + 2
5
6    if l < n and arr[i] < arr[l]:
7        largest = l
8
9    if r < n and arr[largest] < arr[r]:
10        largest = r
11
12    if largest != i:
13        arr[i], arr[largest] = arr[largest], arr[i]
14        heapify(arr, n, largest)
15
16def heap_sort(arr):
17    n = len(arr)
18
19    # 构建初始堆
20    for i in range(n, -1, -1):
21        heapify(arr, n, i)
22
23    # 逐个删除堆顶元素并重新调整堆
24    for i in range(n-1, 0, -1):
25        arr[i], arr[0] = arr[0], arr[i]
26        heapify(arr, i, 0)
27
28# 示例：
29arr = [64, 34, 25, 12, 22, 11, 90]
30heap_sort(arr)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  1. 计数排序 (Counting Sort) / 桶排序 (Bucket Sort) / 基数排序 (Radix Sort): 这些排序算法对于整数排序特别有效，尤其是当输入数据范围较小且分布均匀时。由于它们不适合所有类型的数据，所以有时并不算在“八大排序”之内，但这里也简要介绍一下。
    计数排序是通过对每个输入元素x计算小于x的元素个数，以此确定x在输出数组中的位置。
    桶排序则是将数据分配到有限数量的“桶”中，然后对每个桶独立排序，最后合并所有桶中的数据。
    基数排序是按照低位先排序，然后收集；再按照高位排序，再收集；依次类推，直到最高位。一般用于数字较多的情况，通过遍历每一位并对每一位进行排序来完成整体排序。

请注意，上述代码未考虑特殊情况，例如空列表或单元素列表，在实际应用中应当添加适当的条件判断来确保代码健壮性。同时，对于某些排序算法，特别是快速排序和归并排序，有更为高效的空间优化实现方式。