用c语言实现：随机生成一个包含4000个整数的数组A，再将其按升序排列。在MPI并行环境中使用归并排序算法实现排序，每个进程负责排序一个子数组，然后将所有子数组合并为一个排序数组并输出。要求：将数组A分成8个相等的子数组，其中8为MPI进程数量。第i个MPI进程读取自己负责的子数组A_i。每个进程对自己的子数组A_i进行排序。对于每个进程i，将其负责的子数组发送给进程i+1。进程0从进程p-1接收其负责的子数组，并将所有子数组归并为一个排序数组。所有MPI进程等待，直到所有进程都完成排序和子数组发送。将排序后的数组写回主进程，并输出排序后的结果B到文本文件中。然后使用MPI的计时语句对程序的运行时间进行计时，并输出程序运行所用时间。

这是一个比较复杂的问题，需要使用MPI库来实现并行化。下面是一份可能的代码参考：

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

#define ARRAY_SIZE 4000
#define SUB_ARRAY_SIZE (ARRAY_SIZE / num_procs)

void merge(int *arr, int left, int mid, int right)
{
    int i, j, k;
    int n1 = mid - left + 1;
    int n2 = right - mid;

    // create temp arrays
    int L[n1], R[n2];

    // copy data to temp arrays L[] and R[]
    for (i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    // merge the temp arrays back into arr[left..right]
    i = 0; // initial index of first subarray
    j = 0; // initial index of second subarray
    k = left; // initial index of merged subarray
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        }
        else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // copy the remaining elements of L[], if there are any
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    // copy the remaining elements of R[], if there are any
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

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

        // sort first and second halves
        merge_sort(arr, left, mid);
        merge_sort(arr, mid + 1, right);

        // merge the sorted halves
        merge(arr, left, mid, right);
    }
}

int main(int argc, char **argv)
{
    int i;
    int rank, num_procs;
    int *arr = NULL;
    int *sub_arr = NULL;
    int *tmp_arr = NULL;
    double start_time, end_time;

    // initialize MPI
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &num_procs);

    // allocate memory for arrays
    arr = (int*)malloc(sizeof(int) * ARRAY_SIZE);
    sub_arr = (int*)malloc(sizeof(int) * SUB_ARRAY_SIZE);
    tmp_arr = (int*)malloc(sizeof(int) * ARRAY_SIZE);

    // initialize the array A with random values
    if (rank == 0) {
        for (i = 0; i < ARRAY_SIZE; i++) {
            arr[i] = rand() % 10000;
        }
    }

    // scatter the array A into sub-arrays of size SUB_ARRAY_SIZE
    MPI_Scatter(arr, SUB_ARRAY_SIZE, MPI_INT, sub_arr, SUB_ARRAY_SIZE, MPI_INT, 0, MPI_COMM_WORLD);

    // sort the sub-array
    merge_sort(sub_arr, 0, SUB_ARRAY_SIZE - 1);

    // merge the sub-arrays
    int step = 1;
    while (step < num_procs) {
        if (rank % (2 * step) == 0) {
            if (rank + step < num_procs) {
                MPI_Recv(tmp_arr, SUB_ARRAY_SIZE * step, MPI_INT, rank + step, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
                int i1 = 0;
                int i2 = 0;
                int k = 0;
                while (i1 < SUB_ARRAY_SIZE && i2 < SUB_ARRAY_SIZE * step) {
                    if (sub_arr[i1] <= tmp_arr[i2]) {
                        tmp_arr[k] = sub_arr[i1];
                        i1++;
                    }
                    else {
                        tmp_arr[k] = tmp_arr[i2];
                        i2++;
                    }
                    k++;
                }
                while (i1 < SUB_ARRAY_SIZE) {
                    tmp_arr[k] = sub_arr[i1];
                    i1++;
                    k++;
                }
                while (i2 < SUB_ARRAY_SIZE * step) {
                    tmp_arr[k] = tmp_arr[i2];
                    i2++;
                    k++;
                }
                for (i = 0; i < SUB_ARRAY_SIZE * step; i++) {
                    sub_arr[i] = tmp_arr[i];
                }
            }
        }
        else {
            MPI_Send(sub_arr, SUB_ARRAY_SIZE, MPI_INT, rank - step, 0, MPI_COMM_WORLD);
            break;
        }
        step *= 2;
    }

    // gather the sorted sub-arrays into the sorted array B
    MPI_Gather(sub_arr, SUB_ARRAY_SIZE, MPI_INT, arr, SUB_ARRAY_SIZE, MPI_INT, 0, MPI_COMM_WORLD);

    // write sorted array B to output file
    if (rank == 0) {
        FILE *fp = fopen("output.txt", "w");
        for (i = 0; i < ARRAY_SIZE; i++) {
            fprintf(fp, "%d ", arr[i]);
        }
        fclose(fp);
    }

    // free memory and finalize MPI
    free(arr);
    free(sub_arr);
    free(tmp_arr);
    MPI_Finalize();

    return 0;
}

在该代码中，我们使用了归并排序算法来排序数组。每个进程都负责排序自己的子数组。然后，我们使用递归地将子数组归并为一个大的排列数组，直到所有子数组都被整合到进程0中。在每一步中，进程0向进程i发送子数组，进程i将其子数组与接收到的子数组合并，并将结果发送回进程0。在最后一步中，进程0将排序后的数组写入文件中。

在main函数中，我们首先初始化MPI，并检索当前进程的排名和进程总数。然后，我们为数组A，子数组和临时数组分配内存。在进程0中，我们随机初始化数组A的值。接下来，我们使用MPI_Scatter将A分散到所有进程的子数组中。然后，每个进程使用归并排序算法对其子数组进行排序。在排序完成后，我们使用MPI_Gather将所有子数组收集到进程0中，并将它们作为一个排序后的数组B写入输出文件中。最后，我们释放内存并完成MPI。

值得注意的是，此代码只是一个参考实现。实际上，还有很多优化可以应用于此代码，例如更好的负载平衡，更好的错误处理和更好的通信性能。此外，我们还可以尝试使用其他排序算法，例如快速排序。