c语言实现1.定义待排序表的长度为n。 2.初始化随机数发生器，产生n个随机数构成的顺序表。 3.创建输出排序表函数，取得系统时间函数，直接插入排序函数，冒泡排序函数，快速排序函数，直接选择排序函数，筛选函数，对排序函数，归并排序函数。 4.主程序调用各个排序函数，输出各排序算法对长度为n的顺序表进行排序所耗费的时间。 五、实验记录与数据处理要求 1.当测试数据为10000时，显示结果为： 直接插入排序的时间为：毫秒 冒泡排序的时间为： 毫秒 快速排序的时间为： 毫秒 直接选择排序的时间为：毫秒 堆排序的时间为： 毫秒 2.当测试数据为20000时，显示结果为： 直接插入排序的时间为： 毫秒 冒泡排序的时间为： 毫秒 快速排序的时间为： 毫秒 直接选择排序的时间为： 毫秒 堆排序的时间为： 毫秒

好的，以下是C语言实现不同排序算法测试程序的示例代码：

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

// 定义待排序表长度为n
#define n 20000

// 产生随机数函数
void Random(int *a, int size) {
    for (int i = 0; i < size; i++) {
        a[i] = rand() % 10000 + 1;  // 生成1-10000的随机数
    }
}

// 直接插入排序
void InsertSort(int *a, int size) {
    int i, j, temp;
    for (i = 1; i < size; i++) {
        temp = a[i];
        for (j = i - 1; j >= 0 && a[j] > temp; j--) {
            a[j + 1] = a[j];
        }
        a[j + 1] = temp;
    }
}

// 冒泡排序
void BubbleSort(int *a, int size) {
    int i, j, temp;
    for (i = 0; i < size - 1; i++) {
        for (j = 0; j < size - 1 - i; j++) {
            if (a[j] > a[j + 1]) {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

// 快速排序
void QuickSort(int *a, int left, int right) {
    int i, j, temp, pivot;
    if (left < right) {
        i = left;
        j = right;
        pivot = a[left];  // 选择第一个数为枢轴
        while (i < j) {
            while (i < j && a[j] >= pivot) {
                j--;
            }
            if (i < j) {
                a[i++] = a[j];
            }
            while (i < j && a[i] < pivot) {
                i++;
            }
            if (i < j) {
                a[j--] = a[i];
            }
        }
        a[i] = pivot;
        QuickSort(a, left, i - 1);
        QuickSort(a, i + 1, right);
    }
}

// 直接选择排序
void SelectSort(int *a, int size) {
    int i, j, minIndex, temp;
    for (i = 0; i < size - 1; i++) {
        minIndex = i;
        for (j = i + 1; j < size; j++) {
            if (a[j] < a[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            temp = a[i];
            a[i] = a[minIndex];
            a[minIndex] = temp;
        }
    }
}

// 堆排序
void adjustHeap(int *a, int i, int size) {
    int temp = a[i];
    int j = 2 * i + 1;
    while (j < size) {
        if (j + 1 < size && a[j + 1] > a[j]) {
            j++;
        }
        if (a[j] < temp) {
            break;
        }
        a[i] = a[j];
        i = j;
        j = 2 * i + 1;
    }
    a[i] = temp;
}

void HeapSort(int *a, int size) {
    int i, temp;
    for (i = size / 2 - 1; i >= 0; i--) {
        adjustHeap(a, i, size);
    }
    for (i = size - 1; i > 0; i--) {
        temp = a[0];
        a[0] = a[i];
        a[i] = temp;
        adjustHeap(a, 0, i);
    }
}

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

void MergeSort(int *a, int left, int right, int *temp) {
    if (left < right) {
        int mid = (left + right) / 2;
        MergeSort(a, left, mid, temp);
        MergeSort(a, mid + 1, right, temp);
        Merge(a, left, mid, right, temp);
    }
}

// 输出排序后数组
void Print(int *a, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
}

int main() {
    int a[n], temp[n];

    // 初始化随机数发生器
    srand((unsigned)time(NULL));

    // 产生n个随机数构成的顺序表
    Random(a, n);

    // 直接插入排序
    clock_t start_time = clock();
    InsertSort(a, n);
    clock_t end_time = clock();
    printf("直接插入排序的时间为：%ld毫秒\n", end_time - start_time);

    // 冒泡排序
    Random(a, n);  // 重新生成随机数
    start_time = clock();
    BubbleSort(a, n);
    end_time = clock();
    printf("冒泡排序的时间为：%ld毫秒\n", end_time - start_time);

    // 快速排序
    Random(a, n);  // 重新生成随机数
    start_time = clock();
    QuickSort(a, 0, n - 1);
    end_time = clock();
    printf("快速排序的时间为：%ld毫秒\n", end_time - start_time);

    // 直接选择排序
    Random(a, n);  // 重新生成随机数
    start_time = clock();
    SelectSort(a, n);
    end_time = clock();
    printf("直接选择排序的时间为：%ld毫秒\n", end_time - start_time);

    // 堆排序
    Random(a, n);  // 重新生成随机数
    start_time = clock();
    HeapSort(a, n);
    end_time = clock();
    printf("堆排序的时间为：%ld毫秒\n", end_time - start_time);

    // 归并排序
    Random(a, n);  // 重新生成随机数
    start_time = clock();
    MergeSort(a, 0, n - 1, temp);
    end_time = clock();
    printf("归并排序的时间为：%ld毫秒\n", end_time - start_time);

    return 0;
}

以上代码实现了直接插入排序、冒泡排序、快速排序、直接选择排序、堆排序和归并排序等6种排序算法，并且可以测试不同长度的待排序表所需的时间。