Python 快速排序的迭代和递归基准的结果应该是这样的？

我只是创建了一个基准来比较两个快速排序实现的速度。 迭代和递归

我预计递归速度会慢一些，但我得到了这个图（蓝色是rec）：

递归有可能更快吗？也许我只是在代码中犯了一些错误

以防万一，我会跳过我的代码

    import time
import random
import sys


arrayList = []
arr = [random.randint(1,15000) for _ in range(1000)]

numbersList = [100000, 300000, 500000, 900000, 1000000, 1500000]
numbersForBenchmark = []
for i in range(len(numbersList)):
    arr = [random.randint(1,15000) for _ in range(numbersList[i])]
    numbersForBenchmark.append(arr)

print(numbersForBenchmark)
recursionTimeArray = []
iterationTimeArray = []


arrRe = arr
arrIt = arr



def partition(lst, start, end):
    pos = start

    for i in range(start, end):
        if lst[i] < lst[end]:             # in your version it always goes from 0
            lst[i],lst[pos] = lst[pos],lst[i]
            pos += 1

    lst[pos],lst[end] = lst[end],lst[pos] # you forgot to put the pivot
                                          # back in its place
    return pos

def quick_sort_recursive(lst, start, end):
    if start < end:                       # this is enough to end recursion
        pos = partition(lst, start, end)
        quick_sort_recursive(lst, start, pos - 1)
        quick_sort_recursive(lst, pos + 1, end)
        #print(lst)

def iter(arr,l,h):
    i = ( l - 1 )
    x = arr[h]

    for j in range(l , h):
        if   arr[j] <= x:

            # increment index of smaller element
            i = i+1
            arr[i],arr[j] = arr[j],arr[i]

    arr[i+1],arr[h] = arr[h],arr[i+1]
    return (i+1)

def quickSortIterative(arr,l,h):
    size = h - l + 1
    stack = [0] * (size)

    top = -1

    top = top + 1
    stack[top] = l
    top = top + 1
    stack[top] = h

    while top >= 0:

        # Pop h and l
        h = stack[top]
        top = top - 1
        l = stack[top]
        top = top - 1

        p = iter( arr, l, h )

        if p-1 > l:
            top = top + 1
            stack[top] = l
            top = top + 1
            stack[top] = p - 1

        if p+1 < h:
            top = top + 1
            stack[top] = p + 1
            top = top + 1
            stack[top] = h


for i in range(len(numbersForBenchmark)):
    arrRe = numbersForBenchmark[i][:]
    arrIt = numbersForBenchmark[i][:]

    n = len(arrIt)
    start = time.time()
    quickSortIterative(arrIt, 0, n-1)
    end = time.time()
    ITime = end - start
    iterationTimeArray.append(ITime)


    try:
        n = len(arrRe)
        start = time.time()
        quick_sort_recursive(arrRe,0,n-1)
        end = time.time()
        rekTime = end - start
        recursionTimeArray.append(rekTime)
    except RecursionError as re:
        print('Sorry but this maze solver was not able to finish '
              'analyzing the maze: {}'.format(re.args[0]))


print("REK time", recursionTimeArray)
print("ITER TIME", iterationTimeArray)



# evenly sampled time at 200ms intervals
import matplotlib.pyplot as plt

plt.plot([10,100,500,1000,5000,8000 ], recursionTimeArray,[10,100,500,1000,5000,8000], iterationTimeArray)
plt.show()

导入时间
随机输入
导入系统
arrayList=[]
arr=[random.randint（115000）表示范围内（1000）]
NumberList=[100000、300000、500000、900000、1000000、1500000]
numbersForBenchmark=[]
对于范围内的i（len（numbersList））：
arr=[random.randint（115000）表示范围内的uu（numbersList[i]）]
numbersForBenchmark.append（arr）
打印（数字福布斯标记）
recursionTimeArray=[]
iterationTimeArray=[]
arrRe=arr
arrIt=arr
def分区（lst、开始、结束）：
pos=开始
对于范围内的i（开始、结束）：
如果lst[i]l：
顶部=顶部+1
堆栈[顶部]=l
顶部=顶部+1
堆栈[top]=p-1
如果p+1

---

情节看起来不错，但我预期会有完全不同的结果。因此，我对结果表示怀疑

不要使用

time.time（）

来测量运行时间；至少使用

perf_counter

，但最好使用

timeit

。您显示的图形的

n

值似乎与您测量时间的列表长度不同，并且时间轴没有标记单位（这些是秒、毫秒、）。另外，你的代码中有一些注释，比如“你忘了……”，这看起来像是有人给你的反馈，说你的代码不正确；还有一条错误信息，说的是迷宫。此处发布的代码是否绝对正确？由于python是一种解释性语言，因此会产生很大的开销，而且python对于基准测试算法来说并不理想，例如，通常更快的算法涉及更多行低级代码和更少使用内置功能的情况。