用c语言实现随机产生20个数据，对该数据进行归并排序与快速排序，并输出排序结果。（选做：随机产生10000个数据，输出两种方法的运算时间）。

在C语言中，我们可以使用`rand()`函数生成随机数，然后分别使用归并排序（Merge Sort）和快速排序（Quick Sort）算法对数组进行排序。这里仅给出基本的代码示例，由于涉及到复杂的排序算法和性能计时，实际运行时可能需要额外的库函数如`time.h`来计算时间。

首先，我们创建一个包含20个随机整数的数组：

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

int* generate_random_array(int size) {
    int* arr = malloc(size * sizeof(int));
    srand(time(0)); // 初始化随机种子

    for (int i = 0; i < size; i++) {
        arr[i] = rand() % 100; // 随机生成0到99之间的整数
    }
    return arr;
}

void merge_sort(int* arr, int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        merge_sort(arr, left, mid);
        merge_sort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

// 合并函数，合并两个已排序的部分
void merge(int* arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    int* L = malloc(n1 * sizeof(int));
    int* R = malloc(n2 * sizeof(int));

    for (int i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k++] = L[i++];
        } else {
            arr[k++] = R[j++];
        }
    }

    while (i < n1)
        arr[k++] = L[i++];

    while (j < n2)
        arr[k++] = R[j++];

    free(L);
    free(R);
}

void quick_sort(int* arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quick_sort(arr, low, pi - 1);
        quick_sort(arr, pi + 1, high);
    }
}

// 分区函数，用于快速排序
int partition(int* arr, int low, int high) {
    int pivot = arr[high]; // 最大值作为基准
    int i = (low - 1); // Index of smaller element

    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++; // increment index of smaller element
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void print_array(int* arr, int size) {
    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

int main() {
    int array_size = 20;
    int* arr = generate_random_array(array_size);
    
    printf("Original Array:\n");
    print_array(arr, array_size);

    // 对数组进行排序
    merge_sort(arr, 0, array_size - 1);
    printf("\nSorted by Merge Sort:\n");
    print_array(arr, array_size);

    quick_sort(arr, 0, array_size - 1);
    printf("\nSorted by Quick Sort:\n");
    print_array(arr, array_size);

    free(arr);
    return 0;
}

如果你想要生成10000个随机数据并测量排序时间，可以使用`clock()`函数配合`CLOCKS_PER_SEC`常量，但这需要更复杂的代码结构，因为C标准库并不提供直接的高精度时间测量功能。下面是一个简单的示例，展示了如何获取开始和结束时间：

#include <time.h>

double get_time_in_seconds() {
    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);
    // ... 这里执行排序操作 ...
    clock_gettime(CLOCK_MONOTONIC, &end);
    double time_spent = ((double)end.tv_sec - start.tv_sec) + ((double)end.tv_nsec - start.tv_nsec) / 1e9;
    return time_spent;
}

int main() {
    // ...
    double merge_sort_time = get_time_in_seconds();
    // ... 调用merge_sort ...
    printf("Merge Sort Time: %.6f seconds\n", merge_sort_time);

    double quick_sort_time = get_time_in_seconds();
    // ... 调用quick_sort ...
    printf("Quick Sort Time: %.6f seconds\n", quick_sort_time);

    // ...
}

注意：以上代码未处理内存分配错误，为了生产健壮的应用，在实际项目中应加入适当的错误检查。同时，对于大规模数据排序，通常会使用更专业的性能分析工具，而不是简单的`clock()`函数。