排序代码Python

def quicksort(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 quicksort(left) + middle + quicksort(right)

def shellsort(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

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2

    if left < n and arr[left] > arr[largest]:
        largest = left
    if right < n and arr[right] > arr[largest]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heapsort(arr):
    n = len(arr)
    
    # Build a maxheap.
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
    
    # One by one extract elements
    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]  # swap
        heapify(arr, i, 0)
    return arr

def mergesort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        L = arr[:mid]
        R = arr[mid:]

        mergesort(L)
        mergesort(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

def main():
    # 读取输入
    n = int(input("Enter number of elements: "))
    arr = list(map(int, input("Enter the elements separated by space: ").split()))

    # 复制原始数组
    arr_quick = arr[:]
    arr_shell = arr[:]
    arr_heap = arr[:]
    arr_merge = arr[:]

    # 快速排序
    arr_quick = quicksort(arr_quick)
    print("QuickSort:", arr_quick)

    # 希尔排序
    arr_shell = shellsort(arr_shell)
    print("ShellSort:", arr_shell)

    # 堆排序
    arr_heap = heapsort(arr_heap)
    print("HeapSort:", arr_heap)

    # 归并排序
    arr_merge = mergesort(arr_merge)
    print("MergeSort:", arr_merge)

if __name__ == "__main__":
    main()

其中堆排序可以用 Python 的 heapq 模块

def heapsort(arr):
    import heapq
    h = []
    for value in arr:
        heapq.heappush(h, value)
    return [heapq.heappop(h) for _ in range(len(h))]