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

以下是用C语言实现的代码：

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

#define MAXSIZE 10000 // 待排序表的最大长度

typedef struct {
    int data[MAXSIZE]; // 存放待排序元素的数组
    int length; // 待排序表的长度
} SqList;

// 初始化待排序表
void InitList(SqList *L) {
    int i;
    printf("请输入待排序表的长度：");
    scanf("%d", &L->length);
    srand((unsigned int)time(NULL)); // 初始化随机数发生器
    for (i = 0; i < L->length; i++) {
        L->data[i] = rand() % 1000; // 产生0~999之间的随机整数
    }
}

// 输出排序表
void PrintList(SqList L) {
    int i;
    for (i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}

// 直接插入排序
void InsertionSort(SqList *L) {
    int i, j, temp;
    clock_t start, end;
    start = clock(); // 取得排序开始时间
    for (i = 1; i < L->length; i++) {
        if (L->data[i] < L->data[i - 1]) {
            temp = L->data[i];
            for (j = i - 1; j >= 0 && L->data[j] > temp; j--) {
                L->data[j + 1] = L->data[j];
            }
            L->data[j + 1] = temp;
        }
    }
    end = clock(); // 取得排序结束时间
    printf("直接插入排序所用时间：%lf秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 冒泡排序
void BubbleSort(SqList *L) {
    int i, j, temp;
    clock_t start, end;
    start = clock(); // 取得排序开始时间
    for (i = 0; i < L->length - 1; i++) {
        for (j = L->length - 1; j > i; j--) {
            if (L->data[j] < L->data[j - 1]) {
                temp = L->data[j];
                L->data[j] = L->data[j - 1];
                L->data[j - 1] = temp;
            }
        }
    }
    end = clock(); // 取得排序结束时间
    printf("冒泡排序所用时间：%lf秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 快速排序
int Partition(SqList *L, int low, int high) {
    int pivot = L->data[low]; // 选取第一个元素为枢轴
    while (low < high) {
        while (low < high && L->data[high] >= pivot) high--;
        L->data[low] = L->data[high];
        while (low < high && L->data[low] <= pivot) low++;
        L->data[high] = L->data[low];
    }
    L->data[low] = pivot;
    return low;
}

void QuickSort(SqList *L, int low, int high) {
    if (low < high) {
        int pivotpos = Partition(L, low, high);
        QuickSort(L, low, pivotpos - 1);
        QuickSort(L, pivotpos + 1, high);
    }
}

void QSort(SqList *L) {
    clock_t start, end;
    start = clock(); // 取得排序开始时间
    QuickSort(L, 0, L->length - 1);
    end = clock(); // 取得排序结束时间
    printf("快速排序所用时间：%lf秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 直接选择排序
void SelectionSort(SqList *L) {
    int i, j, min, temp;
    clock_t start, end;
    start = clock(); // 取得排序开始时间
    for (i = 0; i < L->length - 1; i++) {
        min = i;
        for (j = i + 1; j < L->length; j++) {
            if (L->data[j] < L->data[min]) {
                min = j;
            }
        }
        if (min != i) {
            temp = L->data[i];
            L->data[i] = L->data[min];
            L->data[min] = temp;
        }
    }
    end = clock(); // 取得排序结束时间
    printf("直接选择排序所用时间：%lf秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 筛选排序
void HeapAdjust(SqList *L, int i, int len) {
    int j, temp;
    temp = L->data[i];
    for (j = 2 * i; j <= len; j *= 2) {
        if (j < len && L->data[j] < L->data[j + 1]) {
            j++;
        }
        if (temp >= L->data[j]) {
            break;
        }
        L->data[i] = L->data[j];
        i = j;
    }
    L->data[i] = temp;
}

void HeapSort(SqList *L) {
    int i, temp;
    clock_t start, end;
    start = clock(); // 取得排序开始时间
    for (i = L->length / 2; i > 0; i--) {
        HeapAdjust(L, i, L->length);
    }
    for (i = L->length; i > 1; i--) {
        temp = L->data[1];
        L->data[1] = L->data[i];
        L->data[i] = temp;
        HeapAdjust(L, 1, i - 1);
    }
    end = clock(); // 取得排序结束时间
    printf("筛选排序所用时间：%lf秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

// 归并排序
void Merge(int *SR, int *TR, int i, int m, int n) {
    int j, k;
    for (j = m + 1, k = i; i <= m && j <= n; k++) {
        if (SR[i] < SR[j]) {
            TR[k] = SR[i++];
        } else {
            TR[k] = SR[j++];
        }
    }
    while (i <= m) TR[k++] = SR[i++];
    while (j <= n) TR[k++] = SR[j++];
}

void MSort(int *SR, int *TR1, int s, int t) {
    int m;
    int TR2[MAXSIZE + 1];
    if (s == t) {
        TR1[s] = SR[s];
    } else {
        m = (s + t) / 2;
        MSort(SR, TR2, s, m);
        MSort(SR, TR2, m + 1, t);
        Merge(TR2, TR1, s, m, t);
    }
}

void MergeSort(SqList *L) {
    int temp[MAXSIZE]; // 用于临时存放归并排序结果
    clock_t start, end;
    start = clock(); // 取得排序开始时间
    MSort(L->data, temp, 0, L->length - 1);
    end = clock(); // 取得排序结束时间
    printf("归并排序所用时间：%lf秒\n", (double)(end - start) / CLOCKS_PER_SEC);
}

int main() {
    SqList L;
    InitList(&L);
    printf("待排序表为：\n");
    PrintList(L);
    InsertionSort(&L);
    BubbleSort(&L);
    QSort(&L);
    SelectionSort(&L);
    HeapSort(&L);
    MergeSort(&L);
    return 0;
}

该程序可以实现直接插入排序、冒泡排序、快速排序、直接选择排序、筛选排序、归并排序六种排序算法，并输出每种算法对长度为n的顺序表进行排序所耗费的时间。