列。在MPI并行环境中使用归并排序算法实现排序，每个进程负责排序一个子数组，然后将所有子数组合并为一个排序数组并输出。 输入：包含4000个整数的数组A。 输出：排序后的数组A。 算法：八进程，归并排序。 解题提示： 将数组A分成p个相等的子数组，其中p为MPI进程数量。 每个MPI进程读取自己负责的子数组A_i。 每个进程对自己的子数组A_i进行排序。 对于每个进程i，将其负责的子数组发送给进程i+1。 进程0从进程p-1接收其负责的子数组，并将所有子数组归并为一个排序数组。 所有MPI进程等待，直到所有进程都完成排序和子数组发送。 将排序后的数组写回主进程，并输出排序后的结果A到文本文件中。Fprintf语句 使用MPI的计时语句对程序的运行时间进行计时，并输出程序运行所用时间。请给出具体代码，要求代码尽量简单易懂

以下是基于MPI的归并排序代码：

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

void merge(int *arr, int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];
    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void merge_sort(int *arr, int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        merge_sort(arr, l, m);
        merge_sort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

int main(int argc, char **argv) {
    int n = 4000;
    int p = 8;
    int rank, size;
    int *arr = NULL;
    double start, end;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    int chunk_size = n / p;
    arr = (int *) malloc(sizeof(int) * n);
    int *sub_arr = (int *) malloc(sizeof(int) * chunk_size);

    if (rank == 0) {
        FILE *fptr;
        fptr = fopen("input.txt", "r");
        for (int i = 0; i < n; i++)
            fscanf(fptr, "%d", &arr[i]);
        fclose(fptr);

        start = MPI_Wtime();
        MPI_Scatter(arr, chunk_size, MPI_INT, sub_arr, chunk_size, MPI_INT, 0, MPI_COMM_WORLD);
        merge_sort(sub_arr, 0, chunk_size - 1);
    } else {
        MPI_Scatter(arr, chunk_size, MPI_INT, sub_arr, chunk_size, MPI_INT, 0, MPI_COMM_WORLD);
        merge_sort(sub_arr, 0, chunk_size - 1);
    }

    int step = 1;
    while (step < p) {
        if (rank % (2 * step) == 0) {
            if (rank + step < p) {
                int *merge_arr = (int *) malloc(sizeof(int) * chunk_size * 2);
                int merge_size = 0;
                int i = 0, j = 0;
                while (i < chunk_size && j < chunk_size) {
                    if (sub_arr[i] < sub_arr[chunk_size + j]) {
                        merge_arr[merge_size++] = sub_arr[i++];
                    } else {
                        merge_arr[merge_size++] = sub_arr[chunk_size + j++];
                    }
                }
                while (i < chunk_size) {
                    merge_arr[merge_size++] = sub_arr[i++];
                }
                while (j < chunk_size) {
                    merge_arr[merge_size++] = sub_arr[chunk_size + j++];
                }
                MPI_Send(merge_arr, merge_size, MPI_INT, rank + step, 0, MPI_COMM_WORLD);
                free(merge_arr);
            }
        } else if (rank % step == 0) {
            int merge_size = 0;
            MPI_Status status;
            MPI_Probe(rank - step, 0, MPI_COMM_WORLD, &status);
            MPI_Get_count(&status, MPI_INT, &merge_size);
            int *merge_arr = (int *) malloc(sizeof(int) * merge_size);
            MPI_Recv(merge_arr, merge_size, MPI_INT, rank - step, 0, MPI_COMM_WORLD, &status);
            int *new_arr = (int *) malloc(sizeof(int) * 2 * chunk_size);
            int merge_index = 0, i = 0, j = 0;
            while (i < chunk_size && j < merge_size / 2) {
                if (sub_arr[i] < merge_arr[j]) {
                    new_arr[merge_index++] = sub_arr[i++];
                } else {
                    new_arr[merge_index++] = merge_arr[j++];
                }
            }
            while (i < chunk_size) {
                new_arr[merge_index++] = sub_arr[i++];
            }
            while (j < merge_size / 2) {
                new_arr[merge_index++] = merge_arr[j++];
            }
            for (int i = 0; i < chunk_size; i++) {
                sub_arr[i] = new_arr[i];
            }
            free(new_arr);
            free(merge_arr);
        }
        step *= 2;
    }

    if (rank == 0) {
        int *sorted_arr = (int *) malloc(sizeof(int) * n);
        for (int i = 0; i < chunk_size; i++) {
            sorted_arr[i] = sub_arr[i];
        }
        for (int i = 1; i < p; i++) {
            MPI_Status status;
            MPI_Recv(sorted_arr + i * chunk_size, chunk_size, MPI_INT, i, 0, MPI_COMM_WORLD, &status);
        }
        merge_sort(sorted_arr, 0, n - 1);
        end = MPI_Wtime();
        printf("Time taken: %f seconds\n", end - start);

        FILE *fptr;
        fptr = fopen("output.txt", "w");
        for (int i = 0; i < n; i++) {
            fprintf(fptr, "%d ", sorted_arr[i]);
        }
        fclose(fptr);
        free(sorted_arr);
    } else {
        MPI_Send(sub_arr, chunk_size, MPI_INT, 0, 0, MPI_COMM_WORLD);
    }

    free(arr);
    free(sub_arr);
    MPI_Finalize();
    return 0;
}

注：此代码是基于C语言和MPI并行环境中的归并排序算法。假设有一个包含4000个整数的数组A，在8个进程中使用归并排序算法进行排序，每个进程负责排序一个子数组。最后，将所有子数组合并为一个排序后的数组并输出。