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

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

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define LENGTH 20000
#define MAX_VALUE LENGTH*10

void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int temp = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > temp) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
}

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int partition(int arr[], int left, int right) {
    int pivot = arr[left];
    while (left < right) {
        while (left < right && arr[right] >= pivot) {
            right--;
        }
        arr[left] = arr[right];
        while (left < right && arr[left] <= pivot) {
            left++;
        }
        arr[right] = arr[left];
    }
    arr[left] = pivot;
    return left;
}

void quickSort(int arr[], int left, int right) {
    if (left < right) {
        int pivotIndex = partition(arr, left, right);
        quickSort(arr, left, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, right);
    }
}

void heapify(int arr[], int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }
    if (largest != i) {
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    for (int i = n - 1; i >= 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

void merge(int arr[], int left, int mid, int right, int temp[]) {
    int i = left;
    int j = mid + 1;
    int k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    k = 0;
    while (left <= right) {
        arr[left++] = temp[k++];
    }
}

void mergeSort(int arr[], int left, int right, int temp[]) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid, temp);
        mergeSort(arr, mid + 1, right, temp);
        merge(arr, left, mid, right, temp);
    }
}

int main() {
    int arr[LENGTH];
    srand(time(NULL));
    for (int i = 0; i < LENGTH; i++) {
        arr[i] = rand() % MAX_VALUE;
    }

    printf("Original array:\n");
    // printArray(arr, LENGTH);

    printf("\nInsertion sort:\n");
    clock_t start = clock();
    insertionSort(arr, LENGTH);
    clock_t end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nBubble sort:\n");
    start = clock();
    bubbleSort(arr, LENGTH);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nSelection sort:\n");
    start = clock();
    selectionSort(arr, LENGTH);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nQuick sort:\n");
    start = clock();
    quickSort(arr, 0, LENGTH - 1);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nHeap sort:\n");
    start = clock();
    heapSort(arr, LENGTH);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nMerge sort:\n");
    int temp[LENGTH];
    start = clock();
    mergeSort(arr, 0, LENGTH - 1, temp);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    return 0;
}

以上代码中，我们定义了一个包含20000个随机数的数组，值的范围在0到200000之间。然后分别调用各种排序算法，并记录它们的运行时间。最后输出各个排序算法对数组进行排序所花费的时间。可以通过修改LENGTH的值来改变数组的长度。注意，当LENGTH非常大时，排序算法的运行时间会非常长，需要耐心等待。

这里我们使用了clock()函数来获取程序运行的CPU时间，然后计算出各个排序算法的运行时间。请注意，这里的运行时间只是一个参考，实际的运行时间可能会受到多种因素的影响，例如系统负载、硬件配置等。因此，这里的运行时间仅供参考，不代表绝对的准确性。