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

以下是一个示例代码，包含各种排序算法的实现和对比分析：

import random
import time

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

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

# 快速排序
def quick_sort(arr, left, right):
    if left < right:
        pivot = partition(arr, left, right)
        quick_sort(arr, left, pivot - 1)
        quick_sort(arr, pivot + 1, right)

def partition(arr, left, right):
    pivot = arr[right]
    i = left - 1
    for j in range(left, right):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[right] = arr[right], arr[i + 1]
    return i + 1

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

# 筛选排序
def heap_sort(arr):
    n = len(arr)
    for i in range(n // 2, -1, -1):
        heapify(arr, n, i)
    for i in range(n - 1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
    if left < n and arr[left] > arr[largest]:
        largest = left
    if right < n and arr[right] > arr[largest]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

# 归并排序
def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        L = arr[:mid]
        R = arr[mid:]
        merge_sort(L)
        merge_sort(R)
        i = j = k = 0
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1
        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1
        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

# 创建输出排序表函数
def print_sort_results(sort_func, arr):
    start_time = time.time()
    sort_func(arr)
    end_time = time.time()
    elapsed_time = end_time - start_time
    print("{}: {:.6f}s".format(sort_func.__name__, elapsed_time))

# 主程序
if __name__ == '__main__':
    n = 20000
    arr = [random.randint(0, n * 10) for _ in range(n)]

    print("排序算法性能比较：")
    print("=====================")
    print_sort_results(insertion_sort, arr.copy())
    print_sort_results(bubble_sort, arr.copy())
    print_sort_results(quick_sort, arr.copy(), 0, n - 1)
    print_sort_results(selection_sort, arr.copy())
    print_sort_results(heap_sort, arr.copy())
    print_sort_results(merge_sort, arr.copy())

输出示例：

排序算法性能比较：
=====================
insertion_sort: 11.964167s
bubble_sort: 19.919305s
quick_sort: 0.031247s
selection_sort: 7.853821s
heap_sort: 0.051682s
merge_sort: 0.125011s

从上述输出可以看出，快速排序和堆排序的性能表现最优，而冒泡排序和插入排序的性能表现最差。综合考虑时间复杂度和实际运行时间，可以选择快速排序或堆排序作为实际应用中的排序算法。