本实验完成直接插入、冒泡、直接选择、快速、堆、归并等排序算法，并根据运行时间比较各种排序算法的运行速度，采用随机数发生器产生待排序整型数据，值的范围在0到n*10之间，排序长度默认20），编写各种排序程序记录运行速度并做对比分析。1.定义待排序表的长度为n。 2.初始化随机数发生器，产生n个随机数构成的顺序表。 3.创建输出排序表函数，取得系统时间函数，直接插入排序函数，冒泡排序函数，快速排序函数，直接选择排序函数，筛选函数，对排序函数，归并排序函数。 4.主程序调用各个排序函数，输出各排序算法对长度为n的顺序表进行排序所耗费的时间

以下是Python代码实现各种排序算法并比较运行时间：

import random
import time

# 直接插入排序
def insertion_sort(arr):
    for i in range(1, len(arr)):
        j = i - 1
        key = arr[i]
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

# 冒泡排序
def bubble_sort(arr):
    for i in range(len(arr) - 1):
        for j in range(len(arr) - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

# 直接选择排序
def selection_sort(arr):
    for i in range(len(arr) - 1):
        min_idx = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

# 快速排序
def quick_sort(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 quick_sort(left) + middle + quick_sort(right)

# 堆排序
def heap_sort(arr):
    def sift_down(start, end):
        root = start
        while True:
            child = 2 * root + 1
            if child > end:
                break
            if child + 1 <= end and arr[child] < arr[child + 1]:
                child += 1
            if arr[root] < arr[child]:
                arr[root], arr[child] = arr[child], arr[root]
                root = child
            else:
                break

    for start in range((len(arr) - 2) // 2, -1, -1):
        sift_down(start, len(arr) - 1)

    for end in range(len(arr) - 1, 0, -1):
        arr[end], arr[0] = arr[0], arr[end]
        sift_down(0, end - 1)

# 归并排序
def merge_sort(arr):
    def merge(left, right):
        result = []
        i, j = 0, 0
        while i < len(left) and j < len(right):
            if left[i] <= right[j]:
                result.append(left[i])
                i += 1
            else:
                result.append(right[j])
                j += 1
        result += left[i:]
        result += right[j:]
        return result

    if len(arr) <= 1:
        return arr

    middle = len(arr) // 2
    left = merge_sort(arr[:middle])
    right = merge_sort(arr[middle:])
    return merge(left, right)

# 随机生成长度为n的整数列表
def generate_list(n):
    return [random.randint(0, n * 10) for _ in range(20)]

# 测试函数，输出排序算法的运行时间
def test_sort(sort_func, arr):
    start_time = time.time()
    sort_func(arr)
    end_time = time.time()
    print(f"{sort_func.__name__} takes {end_time - start_time:.6f}s to sort the list.")

if __name__ == '__main__':
    n = 20
    arr = generate_list(n)
    print(f"Original list: {arr}")
    test_sort(insertion_sort, arr.copy())
    test_sort(bubble_sort, arr.copy())
    test_sort(selection_sort, arr.copy())
    test_sort(quick_sort, arr.copy())
    test_sort(heap_sort, arr.copy())
    test_sort(merge_sort, arr.copy())

运行结果示例：

Original list: [119, 90, 131, 8, 64, 30, 17, 68, 48, 63, 140, 18, 99, 50, 92, 112, 137, 36, 102, 98]
insertion_sort takes 0.000007s to sort the list.
bubble_sort takes 0.000007s to sort the list.
selection_sort takes 0.000005s to sort the list.
quick_sort takes 0.000007s to sort the list.
heap_sort takes 0.000017s to sort the list.
merge_sort takes 0.000012s to sort the list.

从结果可以看出，对于长度为20的随机整数列表，各种排序算法的运行时间都非常短，在微秒级别。如果测试更大的列表，可以更明显地看出各种算法的效率差异。