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

以下是用 C 语言实现的排序算法：

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

#define MAX_SIZE 10000  // 待排序数组的最大长度

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

// 冒泡排序
void bubble_sort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

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

// 直接选择排序
void select_sort(int arr[], int n) {
    int i, j, min, temp;
    for (i = 0; i < n - 1; i++) {
        min = i;
        for (j = i + 1; j < n; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        if (min != i) {
            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }
}

// 堆排序
void heap_sort(int arr[], int n) {
    int i, temp;
    for (i = n / 2 - 1; i >= 0; i--) {
        adjust_heap(arr, i, n);
    }
    for (i = n - 1; i >= 1; i--) {
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        adjust_heap(arr, 0, i);
    }
}

void adjust_heap(int arr[], int i, int n) {
    int j, temp;
    temp = arr[i];
    j = 2 * i + 1;
    while (j < n) {
        if (j + 1 < n && arr[j + 1] > arr[j]) {
            j++;
        }
        if (arr[j] <= temp) {
            break;
        }
        arr[i] = arr[j];
        i = j;
        j = 2 * i + 1;
    }
    arr[i] = temp;
}

// 归并排序
void merge_sort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }
    int mid = (left + right) / 2;
    merge_sort(arr, left, mid);
    merge_sort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

void merge(int arr[], int left, int mid, int right) {
    int temp[MAX_SIZE];
    int i = left, j = mid + 1, k = left;
    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++];
    }
    for (i = left; i <= right; i++) {
        arr[i] = temp[i];
    }
}

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

// 生成随机数组
void generate_rand_arr(int arr[], int n) {
    int i;
    srand((unsigned)time(NULL));
    for (i = 0; i < n; i++) {
        arr[i] = rand() % MAX_SIZE;
    }
}

// 测试排序算法的效率
void test_sort() {
    int arr[MAX_SIZE];
    int n, i;
    clock_t start, finish;
    double duration;
    printf("请输入待排序数组的长度：");
    scanf("%d", &n);
    generate_rand_arr(arr, n);
    printf("排序前的数组：\n");
    print_arr(arr, n);
    start = clock();
    insert_sort(arr, n);  // 直接插入排序
    // bubble_sort(arr, n);  // 冒泡排序
    // quick_sort(arr, 0, n - 1);  // 快速排序
    // select_sort(arr, n);  // 直接选择排序
    // heap_sort(arr, n);  // 堆排序
    // merge_sort(arr, 0, n - 1);  // 归并排序
    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    printf("排序后的数组：\n");
    print_arr(arr, n);
    printf("排序算法所用时间为：%fs\n", duration);
}

int main() {
    test_sort();
    return 0;
}