C 在指针数组上调用mergesort的Seg错误

我正在尝试使用C语言中的线程。我需要一个线程来处理整个数组的一半，并对它的一半进行合并排序。为此，我为整个数组和两半数组创建了一个全局数组指针。在运行时使用

malloc

分配

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

void *process1(void *arg);
void *process2(void *arg);
void *process3(void *arg);
void *process4(void *arg);
void *process5(void *arg);

void merge(int *arr, int l, int m, int r);
void mergeSort(int *arr, int l, int r);

int *array;
int *arr_first;
int *arr_second;
int arr_s;
size_t n_size;
int n_size_i;
pthread_mutex_t mutex;

main(int argc, char *argv[]) {

    arr_s = atoi(argv[1]);

    n_size = arr_s / 2;
    n_size_i = arr_s / 2;
    
    array = malloc (arr_s * sizeof (int));  
    
    arr_first = malloc(arr_s / 2 * sizeof(int));

    if (arr_s % 2 == 0)
        arr_second = malloc((n_size) * sizeof (int));
    else
        arr_second = malloc((n_size+1) * sizeof(int));
    
    pthread_t tid1, tid2, tid3, tid4, tid5;
    pthread_attr_t attr;

    pthread_attr_init(&attr);
    pthread_mutex_init(&mutex, NULL);

    pthread_create(&tid1, &attr, process1, NULL);
    pthread_join(tid1, NULL);

    printf("---------------------------------------------------------------------------THREAD 2 AND 3 ARE CURRENTLY SORTING THE NUMBERS-------------------------------------------------------------------------\n");

    pthread_create(&tid2, &attr, process2, NULL);
    pthread_create(&tid3, &attr, process3, NULL);
    
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    pthread_create(&tid4, &attr, process4, NULL);   
    pthread_join(tid4, NULL);

    pthread_create(&tid5, &attr, process5, NULL);
    pthread_join(tid5, NULL);

    free(array);
    free(arr_first);
    free(arr_second);
    exit(0);    
}

以下是我的合并和合并排序功能：

//Merges two subarrays of arr[]
//First subarry is arr[l..m]
//Second subarry is arr[m+1..r]
void merge(int *arr, int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;

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

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

    //merge the temp arrays back in arr[l..r]
    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++;
    }

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

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

        //Sort first and second halves
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);

        merge(arr, l, m, r);
    }
}

//合并arr[]的两个子阵列
//第一个子区域是arr[l..m]
//第二个子数组是arr[m+1..r]
无效合并（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]；
//将数据复制到临时数组L[]和R[]
对于（i=0；i如果（L[i]在
mergeSort
中对中点的计算不正确：
L
和
1
之间存在混淆。应该是：

    int m = l + (r - l) / 2;

命名变量
l
非常容易出错。请改用
left
或
low
：

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

        //Sort first and second halves
        mergeSort(arr, left, m);
        mergeSort(arr, m + 1, right);

        merge(arr, left, m, right);
    }
}

void合并排序（int*arr，int左，int右）{
if（左<右）{
int m=左+（右-左）/2；
//对第一部分和第二部分进行排序
合并排序（arr，左，m）；
合并排序（arr，m+1，右）；
合并（arr，左，m，右）；
}
}
在
mergeSort（）
中尝试打印
l
和
r
作为第一条语句；看起来一旦
m
达到1，
l，r
就永远不会从0,1改变，并伴随着无休止的递归和堆栈溢出。@r.Row：您可以通过单击分数下面的灰色复选标记来接受答案。
void mergeSort(int *arr, int left, int right) {
    if (left < right) {
        int m = left + (right - left) / 2;

        //Sort first and second halves
        mergeSort(arr, left, m);
        mergeSort(arr, m + 1, right);

        merge(arr, left, m, right);
    }
}