Python 为什么快速排序测试时间结果看起来是O（n）？

我想用python测试快速排序的时间开销。。 但它似乎总是O（n），它应该是O（nlogn）。。 这是我的密码

def quicksort(arr, left, right):
    if left >=right:
        return 
    random_index = random.randint(left, right)
    arr[left], arr[random_index] = arr[random_index], arr[left]
    pivot = arr[left]
    lt = left
    gt = right + 1
    i = left + 1
    while i < gt:
        if arr[i] < pivot:
            arr[i], arr[lt+1] = arr[lt+1], arr[i]
            lt += 1
            i += 1
        elif arr[i] > pivot:
            arr[i], arr[gt-1] = arr[gt-1], arr[i]
            gt -= 1
        else:
            i += 1
    arr[left], arr[lt] = arr[lt], arr[left]
    quicksort(arr, left, lt-1)
    quicksort(arr, gt, right)


if __name__=='__main__':

    s = 100000
    arr = list(range(0, s))
    random.shuffle(arr)
    start = time.time()
    quicksort(arr, 0, s-1)
    end = time.time()
    print(str(s) + "  ----  " + str(end - start))

    s = 800000
    arr = list(range(0, s))
    random.shuffle(arr)
    start = time.time()
    quicksort(arr, 0, s-1)
    end = time.time()
    print(str(s) + "  ----  " + str(end - start))

    s = 2000000
    arr = list(range(0, s))
    random.shuffle(arr)
    start = time.time()
    quicksort(arr, 0, s-1)
    end = time.time()
    print(str(s) + "  ----  " + str(end - start))

def快速排序（arr、左、右）：
如果左>=右：
返回
random_index=random.randint（左、右）
arr[left]，arr[random_index]=arr[random_index]，arr[left]
枢轴=arr[左]
lt=左
gt=右+1
i=左+1
而我枢轴：
arr[i]，arr[gt-1]=arr[gt-1]，arr[i]
gt-=1
其他：
i+=1
arr[left]，arr[lt]=arr[lt]，arr[left]
快速排序（arr，左侧，lt-1）
快速排序（arr、gt、右侧）
如果“名称”=“\uuuuuuuu主要”：
s=100000
arr=列表（范围（0，s））
随机洗牌（arr）
开始=时间。时间（）
快速排序（arr、0、s-1）
end=time.time（）
打印（str+str（结束-开始））
s=800000
arr=列表（范围（0，s））
随机洗牌（arr）
开始=时间。时间（）
快速排序（arr、0、s-1）
end=time.time（）
打印（str+str（结束-开始））
s=2000000
arr=列表（范围（0，s））
随机洗牌（arr）
开始=时间。时间（）
快速排序（arr、0、s-1）
end=time.time（）
打印（str+str（结束-开始））

这就是结果

我测试了很多情况，尝试了很多输入大小，但总是O（n）。。。

---

我想知道为什么？

首先，您没有线性缩放。您的缩放比例接近n log（n）：

第二，物理运行时间不应用作计算复杂性的度量。它不仅取决于操作的数量，还取决于系统负载和CPU调度

---

第三，在现实中，快速排序不能保证O（n log（n））。在最坏的情况下，当你从一个排序或几乎排序的数组开始时，QS的性能是O（n^2）。

为什么你认为它是O（n）？暂时把许多其他问题放在一边，重要的是要记住，大O符号是算法的理论属性/度量。像这样一个高层次的例子与理论性质相去甚远，我认为我们无法从中做出任何结论性的陈述。

X  =np.array([10000, 100000, 800000, 2000000])
Y = np.array([0.0779, 1.11299, 9.99, 27.679])
Y / (X * np.log(X))
#array([8.458e-07, 9.667e-07, 9.187e-07, 9.539e-07])