1. 冒泡排序 (Bubble Sort)

def bubble_sort(arr):
    n = len(arr)
    # 遍历数组中的每个元素
    for i in range(n):
        # 内层循环，从数组的第一个元素到倒数第 i + 1 个元素
        for j in range(0, n - i - 1):
            # 如果当前元素比下一个元素大，则交换
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

2. 选择排序 (Selection Sort)

def selection_sort(arr):
    n = len(arr)
    # 遍历数组中的每个元素
    for i in range(n):
        # 假设当前元素是最小值
        min_idx = i
        # 通过内层循环找到最小值的索引
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        # 交换当前元素和找到的最小值
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

3. 插入排序 (Insertion Sort)

def insertion_sort(arr):
    # 从第二个元素开始遍历数组
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        # 将当前元素插入到已排序部分的正确位置
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

4. 归并排序 (Merge Sort)

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2  # 找到数组的中间点
        L = arr[:mid]        # 将数组分成两部分
        R = arr[mid:]

        merge_sort(L)  # 递归排序左半部分
        merge_sort(R)  # 递归排序右半部分

        i = j = k = 0
        # 合并两个已排序的子数组
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1

        # 检查是否还有剩余的元素
        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1

        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1
    return arr

5. 快速排序 (Quick Sort)

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]  # 选择数组的中间元素作为基准
    left = [x for x in arr if x < pivot]  # 所有小于基准的元素
    middle = [x for x in arr if x == pivot]  # 所有等于基准的元素
    right = [x for x in arr if x > pivot]  # 所有大于基准的元素
    return quick_sort(left) + middle + quick_sort(right)

6. 堆排序 (Heap Sort)

def heapify(arr, n, i):
    largest = i  # 假设当前节点是最大值
    l = 2 * i + 1  # 左子节点
    r = 2 * i + 2  # 右子节点

    # 如果左子节点存在且大于当前节点
    if l < n and arr[i] < arr[l]:
        largest = l

    # 如果右子节点存在且大于当前最大值
    if r < n and arr[largest] < arr[r]:
        largest = r

    # 如果最大值不是当前节点
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]  # 交换
        heapify(arr, n, largest)  # 递归堆化受影响的子树

def heap_sort(arr):
    n = len(arr)

    # 构建最大堆
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    # 一个个提取元素
    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]  # 交换
        heapify(arr, i, 0)
    return arr

7. 希尔排序 (Shell Sort)

def shell_sort(arr):
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            temp = arr[i]
            j = i
            # 插入排序
            while j >= gap and arr[j - gap] > temp:
                arr[j] = arr[j - gap]
                j -= gap
            arr[j] = temp
        gap //= 2
    return arr

8. 计数排序 (Counting Sort)

def counting_sort(arr):
    max_val = max(arr)
    m = max_val + 1
    count = [0] * m

    # 统计每个元素的个数
    for a in arr:
        count[a] += 1
    i = 0
    for a in range(m):
        for c in range(count[a]):
            arr[i] = a
            i += 1
    return arr

9. 基数排序 (Radix Sort)

def counting_sort_for_radix(arr, exp):
    n = len(arr)
    output = [0] * n
    count = [0] * 10

    # 统计每个基数的个数
    for i in range(n):
        index = arr[i] // exp
        count[index % 10] += 1

    for i in range(1, 10):
        count[i] += count[i - 1]

    i = n - 1
    while i >= 0:
        index = arr[i] // exp
        output[count[index % 10] - 1] = arr[i]
        count[index % 10] -= 1
        i -= 1

    for i in range(n):
        arr[i] = output[i]

def radix_sort(arr):
    max_val = max(arr)
    exp = 1
    while max_val // exp > 0:
        counting_sort_for_radix(arr, exp)
        exp *= 10
    return arr

10. 桶排序 (Bucket Sort)

def bucket_sort(arr):
    if len(arr) == 0:
        return arr

    bucket = []
    slot_num = 10  # 桶的数量
    for i in range(slot_num):
        bucket.append([])

    # 将元素分配到不同的桶中
    for j in arr:
        index = int(slot_num * j)
        bucket[index].append(j)

    # 对每个桶中的元素进行排序
    for i in range(slot_num):
        bucket[i] = insertion_sort(bucket[i])

    k = 0
    for i in range(slot_num):
        for j in range(len(bucket[i])):
            arr[k] = bucket[i][j]
            k += 1
    return arr

11. Tim Sort (Tim Sort)

MIN_MERGE = 32

def calc_min_run(n):
    r = 0
    while n >= MIN_MERGE:
        r |= n & 1
        n >>= 1
    return n + r

def insertion_sort_for_timsort(arr, left, right):
    for i in range(left + 1, right + 1):
        temp = arr[i]
        j = i - 1
        while j >= left and arr[j] > temp:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = temp

def merge_for_timsort(arr, l, m, r):
    len1, len2 = m - l + 1, r - m
    left, right = [], []
    for i in range(0, len1):
        left.append(arr[l + i])
    for i in range(0, len2):
        right.append(arr[m + 1 + i])

    i, j,