本实验完成直接插入、冒泡、直接选择、快速、堆、归并等排序算法，并根据运行时间比较各种排序算法的运行速度。采用随机数发生器产生待排序整型数据，值的范围在0到n*10之间，排序长度默认20000，编写各种排序程序记录运行速度并做对比分析。

好的，这是一个排序算法的实验。针对您的问题，我可以给您一些基本的排序算法的介绍和示例代码。

1. 直接插入排序

直接插入排序是一种简单直观的排序算法，其基本思路是将待排序的数据分为两部分，已排序和未排序。初始时已排序部分只有一个元素，就是原数据中的第一个元素，然后将未排序部分中的元素一个一个插入到已排序部分中，直到所有元素都插入完成。

示例代码：

def insert_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

2. 冒泡排序

冒泡排序是一种交换排序算法，其基本思路是通过比较相邻的两个元素的大小，将较大的元素向后移动，较小的元素向前移动，每一趟排序结束后，最大的元素就会被移动到未排序部分的最后面。

示例代码：

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

3. 直接选择排序

直接选择排序也是一种简单直观的排序算法，其基本思路是将待排序的数据分为两部分，已排序和未排序。初始时已排序部分为空，然后从未排序部分中选择最小的元素，将其放到已排序部分的末尾，直到所有元素都放到已排序部分。

示例代码：

def select_sort(arr):
    for i in range(len(arr)):
        min_index = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]

4. 快速排序

快速排序是一种分治思想的排序算法，其基本思路是通过一次排序将数据分成两部分，递归地对两部分进行排序，直到所有数据都有序。

示例代码：

def quick_sort(arr, left, right):
    if left >= right:
        return
    pivot = arr[left]
    i, j = left, right
    while i < j:
        while i < j and arr[j] >= pivot:
            j -= 1
        arr[i] = arr[j]
        while i < j and arr[i] <= pivot:
            i += 1
        arr[j] = arr[i]
    arr[i] = pivot
    quick_sort(arr, left, i - 1)
    quick_sort(arr, i + 1, right)

5. 堆排序

堆排序是一种基于堆数据结构的排序算法，其基本思路是将待排序的数据建立成一个堆，然后将堆顶元素与堆底元素交换，再将堆的大小减一，继续进行堆调整，直到所有元素都有序。

示例代码：

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

    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[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)

6. 归并排序

归并排序也是一种分治思想的排序算法，其基本思路是将待排序的数据分成两部分，递归地对两部分进行排序，然后将两部分有序的数据合并成一个有序序列。

示例代码：

def merge_sort(arr):
    def merge(arr, left, mid, right):
        left_arr = arr[left:mid]
        right_arr = arr[mid:right]
        i, j, k = 0, 0, left
        while i < len(left_arr) and j < len(right_arr):
            if left_arr[i] < right_arr[j]:
                arr[k] = left_arr[i]
                i += 1
            else:
                arr[k] = right_arr[j]
                j += 1
            k += 1
        while i < len(left_arr):
            arr[k] = left_arr[i]
            i += 1
            k += 1
        while j < len(right_arr):
            arr[k] = right_arr[j]
            j += 1
            k += 1

    def divide(arr, left, right):
        if left + 1 < right:
            mid = (left + right) // 2
            divide(arr, left, mid)
            divide(arr, mid, right)
            merge(arr, left, mid, right)

    divide(arr, 0, len(arr))

这些是常见的排序算法，您可以根据实验要求编写和测试这些算法，并比较它们的运行速度。