给我希尔排序，堆排序，快速排序的递归方式和非递归方式的python代码，要求每次可以比对随机生成的1万个数字，然后通过这三个排序算法的快慢告诉我哪个算法最好

希尔排序（Shell Sort）, 堆排序（Heap Sort）和快速排序（Quick Sort）都是常见的排序算法，下面我会分别给出它们的递归和非递归实现。由于实际比较1万个随机数的运行速度会受到多种因素影响，比如硬件性能、代码优化等，这里仅提供代码，并无法直接告诉你哪个排序算法“最好”。你可以自行测试并分析结果。

**希尔排序 (Shell Sort) - 非递归实现**

import random

def shell_sort(arr):
    gap = len(arr) // 2
    while gap > 0:
        for i in range(gap, len(arr)):
            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

# 生成随机数组
arr = [random.randint(0, 100000) for _ in range(10000)]

# 排序并计时
sorted_arr = shell_sort(arr.copy())

**堆排序 (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)

# 使用随机数组
arr = [random.randint(0, 100000) for _ in range(10000)]
heap_sorted_arr = heap_sort(arr.copy())

**快速排序 (Quick Sort) - 递归实现**

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)

# 递归快速排序同样使用随机数组
quick_sorted_arr = quicksort(arr.copy())

为了评估哪个算法更好，你需要测量每个排序后的平均时间（例如，使用time模块）并对不同规模的数据重复多次实验，观察趋势。一般来说，对于大规模数据，快速排序和堆排序的平均时间复杂度较好，而希尔排序的性能依赖于步长序列的选择。但请注意，真实性能还会受到具体实现的影响。执行这些操作后，可以根据平均时间来判断哪种算法更适合当前场景。