我在 C 中使用动态分配的数组进行合并排序时遇到分段错误（核心转储）错误？

Question

我想我已经凝视了这么久，足以让我的眼睛翻到我的后脑勺。我正在尝试使用动态分配的数组实现升序合并排序，虽然（我相信）我的算法背后的逻辑是正确的，但我得到了分段错误（核心转储）错误。我知道这意味着在某个地方我有一个指针指向它不应该指向的地方，反之亦然，但我似乎无法弄清楚。有什么建议吗？

主要

int main(int argc, char *argv[])
{
  int my_array[ARRAY_SIZE];
  bool sorted = false;

  if( argc != 2)
    {
      printf("Program usage: %s sortname\n", argv[0]);
      return 1;
    }

  // Fill array with random numbers
  initArray(my_array, ARRAY_SIZE);

  // Sort array by chosen algorithm
  if(strcmp(argv[1], "bubble") == 0)
  {
    bubbleSort(my_array, ARRAY_SIZE);
  }
  else if(strcmp(argv[1], "merge") == 0)
    {  
      mergeSort(my_array, ARRAY_SIZE);
    }
  else
    {
      printf("Invalid sort algorithm. Must specifiy 'bubble' or 'merge'\n");
      return 1;
    }

  // Test if array is sorted correctly
  sorted = verifySort(my_array, ARRAY_SIZE);


  if(sorted)
    printf("Congrats! Array is sorted correctly\n");
  else
    printf("*** Error: Array sort algorithm fails verification test ***\n");

  return 0;
}

合并排序

//mergeSort is what I call from main, the array that is passed in is defined as: 
//int my_array[ARRAY_SIZE]; 
//It is filled with random numbers and passed into mergeSort
void mergeSort(int *array_start, int array_size)
{
    printf("Using merge sort algorithm...\n");

    int min = 0;
    int max = array_size-1;

    mergeSortHelper(array_start, min, max);
}

void mergeSortHelper(int *array_start, int min, int max)
{   
    int mid;

    if (min<max)
    {
        mid = (max+min)/2;
        //split into two halves
        mergeSortHelper(array_start, min, mid);     //left half
        mergeSortHelper(array_start, mid+1, max);   //right half
        merge(array_start, min, mid, max);
    }
}

void merge(int *array_start, int min, int mid, int max)
{
    int i, j, k, left, right;

    left = mid - min + 1;
    right = max - mid;

    int *leftArray = calloc(left, sizeof(int));
    int *rightArray = calloc(right, sizeof(int));

    //copy to left temp array
    for(i = 0; i < left; i++)
    {
        leftArray[i] = array_start[min+1];
    }

    //copy to right temp array
    for(j = 0; j < right; j++)
    {
        rightArray[j] = array_start[mid+1+j];
    }

    i = 0;
    j = 0;
    k = min;

    //merge temp arrays 
    while(i < left && j < right)
    {
        if(leftArray[i] <= rightArray[j])
        {
            array_start[k] = leftArray[i];
            i++;
        }
        else
        {
            array_start[k] = rightArray[j];
            j++;
        }
        k++;
    }

    //copy extra elements back to array
    while (i < left)
    {
        array_start[k] = leftArray[j];
        j++;
        k++;
    }

    while (j < right)
    {
        array_start[k] = rightArray[j];
        j++;
        k++;
    }

    free(leftArray);
    free(rightArray);
}

Answer 1

while (i < left)
{
    array_start[k] = leftArray[j];
    j++;
    k++;
}

对我来说，这看起来像是一个无限循环。它内部并没有改变i 或left 的值，所以最终k 或j 增长到足以导致故障。