1.定义待排序表的长度为n。2.初始化随机数发生器，产生n个随机数构成的顺序表。3.创建输出排序表函数，取得系统时间函数，直接插入排序函数，冒泡排序函数，快速排序函数，直接选择排序函数，筛选函数，对排序函数，归并排序函数.4.主程序调用各个排序函数，输出各排序算法对长度为n的顺序表进行排序所耗费的时间。用c语言写

以下是用 C 语言实现的程序，实现了对长度为 n 的顺序表进行各种排序算法的比较，并输出所耗费的时间。

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

#define N 10000   // 待排序表的长度

// 初始化随机数发生器，产生 n 个随机数构成的顺序表
void init(int a[], int n) {
    srand((unsigned)time(NULL));
    for (int i = 0; i < n; i++) {
        a[i] = rand() % 100;
    }
}

// 输出排序表
void print(int a[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
}

// 直接插入排序
void insert_sort(int a[], int n) {
    clock_t start = clock();
    for (int i = 1; i < n; i++) {
        int key = a[i];
        int j = i - 1;
        while (j >= 0 && a[j] > key) {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = key;
    }
    clock_t end = clock();
    printf("直接插入排序用时：%f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 冒泡排序
void bubble_sort(int a[], int n) {
    clock_t start = clock();
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (a[j] > a[j + 1]) {
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
            }
        }
    }
    clock_t end = clock();
    printf("冒泡排序用时：%f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 快速排序
void quick_sort(int a[], int left, int right) {
    if (left >= right) return;
    int i = left, j = right, pivot = a[left];
    while (i < j) {
        while (i < j && a[j] >= pivot) j--;
        a[i] = a[j];
        while (i < j && a[i] <= pivot) i++;
        a[j] = a[i];
    }
    a[i] = pivot;
    quick_sort(a, left, i - 1);
    quick_sort(a, i + 1, right);
}

// 直接选择排序
void select_sort(int a[], int n) {
    clock_t start = clock();
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (a[j] < a[min_idx]) {
                min_idx = j;
            }
        }
        int tmp = a[i];
        a[i] = a[min_idx];
        a[min_idx] = tmp;
    }
    clock_t end = clock();
    printf("直接选择排序用时：%f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 筛选函数
void sift(int a[], int left, int right) {
    int i = left, j = 2 * i + 1, tmp = a[i];
    while (j <= right) {
        if (j < right && a[j] < a[j + 1]) j++;
        if (tmp < a[j]) {
            a[i] = a[j];
            i = j;
            j = 2 * i + 1;
        }
        else
            break;
    }
    a[i] = tmp;
}

// 堆排序
void heap_sort(int a[], int n) {
    clock_t start = clock();
    for (int i = n / 2 - 1; i >= 0; i--) {
        sift(a, i, n - 1);
    }
    for (int i = n - 1; i >= 1; i--) {
        int tmp = a[0];
        a[0] = a[i];
        a[i] = tmp;
        sift(a, 0, i - 1);
    }
    clock_t end = clock();
    printf("堆排序用时：%f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 归并排序
void merge(int a[], int left, int mid, int right, int tmp[]) {
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        if (a[i] <= a[j]) {
            tmp[k++] = a[i++];
        }
        else {
            tmp[k++] = a[j++];
        }
    }
    while (i <= mid) {
        tmp[k++] = a[i++];
    }
    while (j <= right) {
        tmp[k++] = a[j++];
    }
    for (i = 0; i < k; i++) {
        a[left + i] = tmp[i];
    }
}

void merge_sort(int a[], int left, int right, int tmp[]) {
    if (left >= right) return;
    int mid = (left + right) / 2;
    merge_sort(a, left, mid, tmp);
    merge_sort(a, mid + 1, right, tmp);
    merge(a, left, mid, right, tmp);
}

// 主函数
int main() {
    int a[N];
    init(a, N);
    printf("排序前：\n");
    print(a, N);

    int tmp[N];
    // 直接插入排序
    insert_sort(a, N);

    // 冒泡排序
    init(a, N);
    bubble_sort(a, N);

    // 快速排序
    init(a, N);
    clock_t start = clock();
    quick_sort(a, 0, N - 1);
    clock_t end = clock();
    printf("快速排序用时：%f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 直接选择排序
    init(a, N);
    select_sort(a, N);

    // 堆排序
    init(a, N);
    heap_sort(a, N);

    // 归并排序
    init(a, N);
    start = clock();
    merge_sort(a, 0, N - 1, tmp);
    end = clock();
    printf("归并排序用时：%f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    printf("排序后：\n");
    print(a, N);

    return 0;
}

在主函数中，首先调用 `init` 函数初始化随机数发生器，产生 n 个随机数构成的顺序表。然后依次调用各个排序算法的函数，输出它们对长度为 n 的顺序表进行排序所耗费的时间。最后输出排序后的顺序表。

注意，堆排序和归并排序的实现使用了辅助数组 `tmp`，用于存储归并时的中间结果。另外，快速排序的实现使用了递归。