利用C++，不用类函数，使用线性表顺序存储结构实现采用几组不同数据测试以下排序算法的时间性能，并输出各种排序的时间 直接插入排序 希尔排序 冒泡排序 快速排序 直接选择排序 堆排序

好的，这是一个比较复杂的问题，需要写一些代码。以下是实现的示例代码：

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

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

// 希尔排序
void shellSort(int arr[], int n) {
    int gap = n / 2;
    while (gap > 0) {
        for (int i = gap; i < n; i++) {
            int tmp = arr[i];
            int j = i - gap;
            while (j >= 0 && arr[j] > tmp) {
                arr[j + gap] = arr[j];
                j -= gap;
            }
            arr[j + gap] = tmp;
        }
        gap /= 2;
    }
}

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

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

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

// 堆排序
void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        int k = i;
        int tmp = arr[k];
        int child = 2 * k + 1;
        while (child < n) {
            if (child + 1 < n && arr[child] < arr[child + 1]) {
                child++;
            }
            if (tmp < arr[child]) {
                arr[k] = arr[child];
                k = child;
                child = 2 * k + 1;
            }
            else {
                break;
            }
        }
        arr[k] = tmp;
    }
    for (int i = n - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        int k = 0;
        int tmp = arr[k];
        int child = 2 * k + 1;
        while (child < i) {
            if (child + 1 < i && arr[child] < arr[child + 1]) {
                child++;
            }
            if (tmp < arr[child]) {
                arr[k] = arr[child];
                k = child;
                child = 2 * k + 1;
            }
            else {
                break;
            }
        }
        arr[k] = tmp;
    }
}

// 生成随机数组
void generateRandomArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % n;
    }
}

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

// 测试排序算法时间性能
void testSort(int n) {
    int arr1[n], arr2[n], arr3[n], arr4[n], arr5[n], arr6[n];
    generateRandomArray(arr1, n);
    generateRandomArray(arr2, n);
    generateRandomArray(arr3, n);
    generateRandomArray(arr4, n);
    generateRandomArray(arr5, n);
    generateRandomArray(arr6, n);

    clock_t start, end;

    // 直接插入排序
    start = clock();
    insertSort(arr1, n);
    end = clock();
    cout << "直接插入排序：" << (double)(end - start) / CLOCKS_PER_SEC << "秒" << endl;

    // 希尔排序
    start = clock();
    shellSort(arr2, n);
    end = clock();
    cout << "希尔排序：" << (double)(end - start) / CLOCKS_PER_SEC << "秒" << endl;

    // 冒泡排序
    start = clock();
    bubbleSort(arr3, n);
    end = clock();
    cout << "冒泡排序：" << (double)(end - start) / CLOCKS_PER_SEC << "秒" << endl;

    // 快速排序
    start = clock();
    quickSort(arr4, 0, n - 1);
    end = clock();
    cout << "快速排序：" << (double)(end - start) / CLOCKS_PER_SEC << "秒" << endl;

    // 直接选择排序
    start = clock();
    selectSort(arr5, n);
    end = clock();
    cout << "直接选择排序：" << (double)(end - start) / CLOCKS_PER_SEC << "秒" << endl;

    // 堆排序
    start = clock();
    heapSort(arr6, n);
    end = clock();
    cout << "堆排序：" << (double)(end - start) / CLOCKS_PER_SEC << "秒" << endl;
}

int main() {
    srand((unsigned)time(NULL));

    testSort(10000);

    return 0;
}

这个程序会生成一个大小为10000的随机数组，然后分别使用直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序对数组进行排序，并输出每种排序算法的时间。你可以根据需要修改数组大小和排序算法进行测试。