4.排序综合 利用随机函数产生N个随机整数(20000以上)，对这些数进行多种方法进行排序。要求： 1）至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。并把排序后的结果保存在不同的文件中。 2）统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。 3)如果采用4种或4种以上的方法者，可适当加分。c语言实现，对代码加注释

好的，我明白了。这是一个排序综合的问题，需要使用至少三种不同的排序方法对一组随机整数进行排序。同时，需要统计每种方法的性能并找出其中两种较快的方法。以下是C语言实现的示例代码，我会加上注释来帮助你理解。

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

// 生成随机数
void generateRandomArray(int arr[], int n) {
    srand(time(NULL));
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % 100000 + 20000; // 生成20000以上的随机整数
    }
}

// 冒泡排序
void bubbleSort(int arr[], int n) {
    int temp;
    for (int i = 0; i < n - 1; i++) {
        for (int 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 insertionSort(int arr[], int n) {
    int i, j, temp;
    for (i = 1; i < n; i++) {
        temp = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > temp) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
}

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

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

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

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

// 归并排序
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 merge(int arr[], int left, int mid, int right) {
    int temp[right - left + 1];
    int i = left, j = mid + 1, k = 0;
    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, k = 0; i <= right; i++, k++) {
        arr[i] = temp[k];
    }
}

int main() {
    int n = 10000; // 数组大小
    int arr1[n], arr2[n], arr3[n];
    generateRandomArray(arr1, n);
    for (int i = 0; i < n; i++) {
        arr2[i] = arr1[i];
        arr3[i] = arr1[i];
    }

    clock_t start, end;
    double duration;

    // 冒泡排序
    start = clock();
    bubbleSort(arr1, n);
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    printf("Bubble sort time: %f seconds\n", duration);
    FILE *fp1 = fopen("bubbleSort.txt", "w");
    for (int i = 0; i < n; i++) {
        fprintf(fp1, "%d ", arr1[i]);
    }
    fclose(fp1);

    // 插入排序
    start = clock();
    insertionSort(arr2, n);
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    printf("Insertion sort time: %f seconds\n", duration);
    FILE *fp2 = fopen("insertionSort.txt", "w");
    for (int i = 0; i < n; i++) {
        fprintf(fp2, "%d ", arr2[i]);
    }
    fclose(fp2);

    // 快速排序
    start = clock();
    quickSort(arr3, 0, n - 1);
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    printf("Quick sort time: %f seconds\n", duration);
    FILE *fp3 = fopen("quickSort.txt", "w");
    for (int i = 0; i < n; i++) {
        fprintf(fp3, "%d ", arr3[i]);
    }
    fclose(fp3);

    // 选择排序
    start = clock();
    selectionSort(arr1, n);
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    printf("Selection sort time: %f seconds\n", duration);

    // 堆排序
    start = clock();
    heapSort(arr2, n);
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    printf("Heap sort time: %f seconds\n", duration);

    // 归并排序
    start = clock();
    mergeSort(arr3, 0, n - 1);
    end = clock();
    duration = (double)(end - start) / CLOCKS_PER_SEC;
    printf("Merge sort time: %f seconds\n", duration);

    return 0;
}

这个示例代码中，我们采用了冒泡排序、插入排序和快速排序三种方法对随机整数进行排序，并将排序结果保存在不同的文件中。同时，我们还实现了选择排序、堆排序和归并排序，但没有将排序结果保存在文件中。

在统计性能方面，我们使用了clock函数来测量程序运行时间，并输出排序所需的时间。根据输出结果，我们可以找出其中两种较快的方法。