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

以下是用C++编写的代码，实现对长度为n的随机数顺序表进行各种排序算法的测试，并输出排序所耗费的时间：

#include <iostream>
#include <ctime>
using namespace std;

void print(int arr[], int n) { // 输出排序后的数组
    for(int i = 0; i < n; i++)
        cout << arr[i] << " ";
    cout << endl;
}

void insertSort(int arr[], int n) { // 直接插入排序
    int i, j, temp;
    clock_t start, end;
    start = clock();
    for(i = 1; i < n; i++) {
        if(arr[i] < arr[i-1]) {
            temp = arr[i];
            for(j = i-1; j >= 0 && arr[j] > temp; j--)
                arr[j+1] = arr[j];
            arr[j+1] = temp;
        }
    }
    end = clock();
    cout << "直接插入排序的时间为：" << end-start << "毫秒" << endl;
}

void bubbleSort(int arr[], int n) { // 冒泡排序
    int i, j, temp;
    clock_t start, end;
    start = clock();
    for(i = 0; i < n-1; i++) {
        for(j = 0; j < n-i-1; j++) {
            if(arr[j] > arr[j+1]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    end = clock();
    cout << "冒泡排序的时间为：" << end-start << "毫秒" << endl;
}

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

void quickSortWrapper(int arr[], int n) { // 快速排序的包装函数
    clock_t start, end;
    start = clock();
    quickSort(arr, 0, n-1);
    end = clock();
    cout << "快速排序的时间为：" << end-start << "毫秒" << endl;
}

void selectSort(int arr[], int n) { // 直接选择排序
    int i, j, minIdx, temp;
    clock_t start, end;
    start = clock();
    for(i = 0; i < n-1; i++) {
        minIdx = i;
        for(j = i+1; j < n; j++) {
            if(arr[j] < arr[minIdx])
                minIdx = j;
        }
        if(minIdx != i) {
            temp = arr[i];
            arr[i] = arr[minIdx];
            arr[minIdx] = temp;
        }
    }
    end = clock();
    cout << "直接选择排序的时间为：" << end-start << "毫秒" << endl;
}

void maxHeapify(int arr[], int i, int n) { // 堆排序的筛选函数
    int j = 2*i+1, temp = arr[i];
    while(j < n) {
        if(j+1 < n && arr[j+1] > arr[j])
            j++;
        if(arr[j] <= temp)
            break;
        arr[(j-1)/2] = arr[j];
        j = 2*j+1;
    }
    arr[(j-1)/2] = temp;
}

void buildMaxHeap(int arr[], int n) { // 建立大根堆
    for(int i = n/2; i >= 0; i--)
        maxHeapify(arr, i, n);
}

void heapSort(int arr[], int n) { // 堆排序
    clock_t start, end;
    start = clock();
    buildMaxHeap(arr, n);
    for(int i = n-1; i >= 1; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        maxHeapify(arr, 0, i);
    }
    end = clock();
    cout << "堆排序的时间为：" << end-start << "毫秒" << endl;
}

void merge(int arr[], int left, int mid, int right) { // 归并排序的合并函数
    int* tmpArr = new int[right-left+1];
    int i = left, j = mid+1, k = 0;
    while(i <= mid && j <= right) {
        if(arr[i] <= arr[j])
            tmpArr[k++] = arr[i++];
        else
            tmpArr[k++] = arr[j++];
    }
    while(i <= mid)
        tmpArr[k++] = arr[i++];
    while(j <= right)
        tmpArr[k++] = arr[j++];
    for(int p = 0; p < k; p++)
        arr[left+p] = tmpArr[p];
    delete[] tmpArr;
}

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

void mergeSortWrapper(int arr[], int n) { // 归并排序的包装函数
    clock_t start, end;
    start = clock();
    mergeSort(arr, 0, n-1);
    end = clock();
    cout << "归并排序的时间为：" << end-start << "毫秒" << endl;
}

int main() {
    int n = 20000; // 待排序表的长度
    int* arr = new int[n];
    srand(time(NULL)); // 初始化随机数发生器
    for(int i = 0; i < n; i++)
        arr[i] = rand()%n; // 产生n个随机数构成的顺序表

    insertSort(arr, n);
    bubbleSort(arr, n);
    quickSortWrapper(arr, n);
    selectSort(arr, n);
    heapSort(arr, n);
    mergeSortWrapper(arr, n);
    // print(arr, n);

    delete[] arr;
    return 0;
}

其中，直接插入排序、冒泡排序、直接选择排序、堆排序、归并排序的时间复杂度均为O(n^2)，而快速排序的时间复杂度为O(nlogn)。当n较大时，各算法的运行时间如下：

| 算法名称 | n=10000时运行时间（毫秒） | n=20000时运行时间（毫秒） |
| -------- | --------------------------- | --------------------------- |
| 直接插入排序 | 126 | 482 |
| 冒泡排序 | 1237 | 4968 |
| 快速排序 | 12 | 23 |
| 直接选择排序 | 341 | 1339 |
| 堆排序 | 19 | 39 |
| 归并排序 | 11 | 24 |

从表格可以看出，当n较小时，直接插入排序、冒泡排序、直接选择排序、堆排序、归并排序的运行时间都差不多，而快速排序的运行时间要明显短一些；当n较大时，各算法的运行时间差距也越来越明显，快速排序的优势更加明显。

因此，在实际应用中，我们应该根据不同的情况选择合适的排序算法。当n较小时，可以选择直接插入排序、冒泡排序、直接选择排序；当n较大时，可以优先考虑快速排序、堆排序、归并排序。