用c语言写一个程序要求随机产生10000个数据，并且分别进行起泡排序、快速排序、希尔排序、堆排序、基数排序，并比较各种算法的排序时间

好的，以下是一个简单的C语言程序，可以实现随机产生10000个数据，并分别用起泡排序、快速排序、希尔排序、堆排序和基数排序进行排序，并比较它们的排序时间。

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

#define LENGTH 10000

// 交换两个元素的值
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 起泡排序
void bubbleSort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n - 1; i++) {
        for (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) {
        int pivot = arr[left];
        int low = left;
        int high = right;
        while (low < high) {
            while (low < high && arr[high] >= pivot) {
                high--;
            }
            arr[low] = arr[high];
            while (low < high && arr[low] <= pivot) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = pivot;
        quickSort(arr, left, low - 1);
        quickSort(arr, low + 1, right);
    }
}

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

// 堆排序
void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    if (l < n && arr[l] > arr[largest]) {
        largest = l;
    }
    if (r < n && arr[r] > arr[largest]) {
        largest = r;
    }
    if (largest != i) {
        swap(&arr[i], &arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    int i;
    for (i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    for (i = n - 1; i >= 0; i--) {
        swap(&arr[0], &arr[i]);
        heapify(arr, i, 0);
    }
}

// 基数排序
void radixSort(int arr[], int n) {
    int i, j, m = arr[0], exp = 1;
    int *bucket = (int *)malloc(sizeof(int) * n);
    for (i = 1; i < n; i++) {
        if (arr[i] > m) {
            m = arr[i];
        }
    }
    while (m / exp > 0) {
        int bucketCount[10] = {0};
        for (i = 0; i < n; i++) {
            bucketCount[arr[i] / exp % 10]++;
        }
        for (i = 1; i < 10; i++) {
            bucketCount[i] += bucketCount[i - 1];
        }
        for (i = n - 1; i >= 0; i--) {
            bucket[--bucketCount[arr[i] / exp % 10]] = arr[i];
        }
        for (i = 0; i < n; i++) {
            arr[i] = bucket[i];
        }
        exp *= 10;
    }
    free(bucket);
}

int main() {
    int arr[LENGTH], i;
    clock_t start, end;

    // 产生随机数
    srand((unsigned)time(NULL));
    for (i = 0; i < LENGTH; i++) {
        arr[i] = rand() % 100000;
    }

    // 起泡排序
    start = clock();
    bubbleSort(arr, LENGTH);
    end = clock();
    printf("Bubble sort time: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 快速排序
    start = clock();
    quickSort(arr, 0, LENGTH - 1);
    end = clock();
    printf("Quick sort time: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 希尔排序
    start = clock();
    shellSort(arr, LENGTH);
    end = clock();
    printf("Shell sort time: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);

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

    // 基数排序
    start = clock();
    radixSort(arr, LENGTH);
    end = clock();
    printf("Radix sort time: %f s\n", (double)(end - start) / CLOCKS_PER_SEC);

    return 0;
}

在这个程序中，我们使用 srand() 和 rand() 函数来生成随机数，并将其存储在一个长度为 10000 的数组中。然后，我们分别使用起泡排序、快速排序、希尔排序、堆排序和基数排序对这个数组进行排序，并使用 clock() 函数来测量每个排序算法的执行时间。最后，我们将每个算法的执行时间输出到控制台上。

需要注意的一点是，由于每个排序算法的时间复杂度不同，因此它们的执行时间也会有所差异。因此，在比较这些算法的性能时，需要考虑到这一点。