用C++写一段代码 定义待排序表的长度为n。 初始化随机数发生器，产生n个随机数构成的顺序表。 创建输出排序表函数，取得系统时间函数，直接插入排序函数，冒泡排序函数，快速排序函数，直接选择排序函数，筛选函数，对排序函数，归并排序函数。 主程序调用各个排序函数，输出各排序算法对长度为n的顺序表进行排序所耗费的时间为多少毫秒。

以下是C++代码：

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

void initArray(int a[], int n) {
    srand(time(NULL)); // 初始化随机数发生器
    for (int i = 0; i < n; i++) {
        a[i] = rand() % 100; // 生成0-99之间的随机数
    }
}

void printArray(int a[], int n) {
    for (int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
}

void insertionSort(int a[], int n) {
    int i, j, temp;
    for (i = 1; i < n; 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 n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 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) {
    if (left >= right) {
        return;
    }
    int i = left, j = right, pivot = a[(left + right) / 2];
    while (i <= j) {
        while (a[i] < pivot) {
            i++;
        }
        while (a[j] > pivot) {
            j--;
        }
        if (i <= j) {
            swap(a[i], a[j]);
            i++;
            j--;
        }
    }
    quickSort(a, left, j);
    quickSort(a, i, right);
}

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

void sieveSort(int a[], int n) {
    int i, j, temp, k = n / 2;
    while (k >= 1) {
        for (i = k; i < n; i++) {
            temp = a[i];
            j = i - k;
            while (j >= 0 && a[j] > temp) {
                a[j + k] = a[j];
                j -= k;
            }
            a[j + k] = temp;
        }
        k /= 2;
    }
}

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

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

int main() {
    int n = 10; // 待排序表的长度
    int a[n]; // 声明顺序表
    initArray(a, n); // 初始化顺序表
    cout << "原始数组：";
    printArray(a, n); // 输出原始顺序表
    clock_t start, end; // 声明计时器
    // 直接插入排序
    start = clock();
    insertionSort(a, n);
    end = clock();
    cout << "直接插入排序后的数组：";
    printArray(a, n);
    cout << "直接插入排序耗时：" << (double)(end - start) / CLOCKS_PER_SEC * 1000 << "毫秒" << endl;
    // 冒泡排序
    initArray(a, n); // 重新初始化顺序表
    start = clock();
    bubbleSort(a, n);
    end = clock();
    cout << "冒泡排序后的数组：";
    printArray(a, n);
    cout << "冒泡排序耗时：" << (double)(end - start) / CLOCKS_PER_SEC * 1000 << "毫秒" << endl;
    // 快速排序
    initArray(a, n); // 重新初始化顺序表
    start = clock();
    quickSort(a, 0, n - 1);
    end = clock();
    cout << "快速排序后的数组：";
    printArray(a, n);
    cout << "快速排序耗时：" << (double)(end - start) / CLOCKS_PER_SEC * 1000 << "毫秒" << endl;
    // 直接选择排序
    initArray(a, n); // 重新初始化顺序表
    start = clock();
    selectionSort(a, n);
    end = clock();
    cout << "直接选择排序后的数组：";
    printArray(a, n);
    cout << "直接选择排序耗时：" << (double)(end - start) / CLOCKS_PER_SEC * 1000 << "毫秒" << endl;
    // 筛选排序
    initArray(a, n); // 重新初始化顺序表
    start = clock();
    sieveSort(a, n);
    end = clock();
    cout << "筛选排序后的数组：";
    printArray(a, n);
    cout << "筛选排序耗时：" << (double)(end - start) / CLOCKS_PER_SEC * 1000 << "毫秒" << endl;
    // 归并排序
    initArray(a, n); // 重新初始化顺序表
    start = clock();
    mergeSort(a, 0, n - 1);
    end = clock();
    cout << "归并排序后的数组：";
    printArray(a, n);
    cout << "归并排序耗时：" << (double)(end - start) / CLOCKS_PER_SEC * 1000 << "毫秒" << endl;
    return 0;
}