python中歸並排序、插入排序和遞歸插入排序的運行時比較

Question

def merge_sort(unorderedList):
    if len(unorderedList) > 1:
        mid = len(unorderedList) // 2 
        left = unorderedList[:mid]
        right = unorderedList[mid:]
        merge_sort(left)
        merge_sort(right)
        i = 0
        j = 0
        k = 0
        while i < len(left) and j < len(right):
            if left[i] < right[j]:
                unorderedList[k] = left[i]
                i += 1
            else:
                unorderedList[k] = right[j]
                j += 1
            k += 1
        while i < len(left):
            unorderedList[k] = left[i]
            i += 1
            k += 1
        while j < len(right):
            unorderedList[k] = right[j]
            j += 1
            k += 1

def insertion_sort(list1):
    for i in range(1, len(list1)):
        key = list1[i]
        j = i - 1 
        while j >= 0 and list1[j] > key:
            list1[j + 1] = list1[j]
            j -= 1
        list1[j + 1] = key

def recursive_insertion_sort(arr, n):
    if n <= 1:
        return

    recursive_insertion_sort(arr, n-1)
    last = arr[n-1]
    j = n-2
     
    while j >= 0 and arr[j] > last:
        arr[j + 1] = arr[j]
        j -= 1
 
    arr[j + 1] = last

我使用這三個函數在 5 萬個成員隨機列表上比較它們的運行時
我在 vscode 中使用 python 3.10 獲得了這些時間

插入排序計時器：78.13s
遞歸插入排序計時器：0.068s
合並排序計時器：0.209s
這樣對嗎？ 如果是這樣，你能解釋一下嗎？
考慮到歸並排序的順序為 O(nlogn)，插入排序的順序為 O(n^2)，這是怎么發生的？

Answer 1

您的插入排序正在處理原始列表中的“內聯”元素，但合並排序實現遞歸地制作列表的副本（因為切片下標），這增加了其他函數沒有的開銷。 遞歸還增加了一些開銷。

要將蘋果與蘋果進行比較，您應該在不復制列表的情況下實現歸並排序。

這可能很好地說明了復雜性如何不一定等同於時間（或空間）取決於成本因素所在的位置。