C语言.实现合并排序算法。要排序的整型数组元素可以用随机数生成器生成，运行程序，分别记录对十万，一百万，一千万，五千万个数据排序所用的时间，列出表格显示统计出来的时间。并单独显示一个100个数据的排序结果。

好的，这是一个C语言版本的实现合并排序算法的代码，同样会生成随机的整型数组，并计算排序所用的时间，最后输出排序结果和时间统计表格：

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

void merge(int arr[], int left_start, int left_end, int right_start, int right_end) {
    int i, j, k;
    int left_size = left_end - left_start + 1;
    int right_size = right_end - right_start + 1;
    int left_half[left_size], right_half[right_size];

    for (i = left_start, k = 0; i <= left_end; i++, k++) {
        left_half[k] = arr[i];
    }
    for (j = right_start, k = 0; j <= right_end; j++, k++) {
        right_half[k] = arr[j];
    }

    i = j = 0;
    k = left_start;
    while (i < left_size && j < right_size) {
        if (left_half[i] < right_half[j]) {
            arr[k] = left_half[i];
            i++;
        }
        else {
            arr[k] = right_half[j];
            j++;
        }
        k++;
    }

    while (i < left_size) {
        arr[k] = left_half[i];
        i++;
        k++;
    }

    while (j < right_size) {
        arr[k] = right_half[j];
        j++;
        k++;
    }
}

void merge_sort(int arr[], int start, int end) {
    if (start < end) {
        int mid = (start + end) / 2;
        merge_sort(arr, start, mid);
        merge_sort(arr, mid + 1, end);
        merge(arr, start, mid, mid + 1, end);
    }
}

int* generate_random_array(int n) {
    int* arr = (int*)malloc(n * sizeof(int));
    int i;
    for (i = 0; i < n; i++) {
        arr[i] = rand() % 1000000;
    }
    return arr;
}

int main() {
    srand(time(NULL));
    clock_t start, end;
    double time_used;

    int n_values[] = {100000, 1000000, 10000000, 50000000};
    int n_values_size = sizeof(n_values) / sizeof(n_values[0]);
    int i, j;

    printf("Sorting %d values...\n", n_values[0]);
    int* arr = generate_random_array(n_values[0]);
    start = clock();
    merge_sort(arr, 0, n_values[0] - 1);
    end = clock();
    printf("Sorted array of %d values:\n", n_values[0]);
    for (i = 0; i < 100; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Time used: %f seconds.\n", time_used);
    free(arr);

    for (j = 1; j < n_values_size; j++) {
        printf("\nSorting %d values...\n", n_values[j]);
        arr = generate_random_array(n_values[j]);
        start = clock();
        merge_sort(arr, 0, n_values[j] - 1);
        end = clock();
        time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
        printf("Time used: %f seconds.\n", time_used);
        free(arr);
    }
    return 0;
}

代码中 `merge` 函数实现了合并操作， `merge_sort` 函数实现了合并排序算法，同样可以生成随机的整型数组。通过 `clock` 函数可以计算出程序运行的时间。我们分别对输入大小为十万、一百万、一千万和五千万的随机数组进行排序，并输出程序运行时间。同时，我们也对一个大小为100的随机数组进行排序，并输出排序结果。

注意，由于合并排序算法的时间复杂度为 $O(n\log n)$，随着输入大小的增加，程序的运行时间增长速度比较慢，但是对于非常大的输入，程序的运行时间也会非常长。因此，如果您的电脑配置较低，可能需要等待一段时间才能看到程序的输出结果。