哪个合并排序实现是首选...为什么？

Question

我在 C++ 中实现合并排序，我在 GeeksforGeeks 上遇到了一个实现。 在我的实现中，我在每次调用时计算并传递了数组的大小。 我在 GFG 上看到的实现是通过在每次调用中传递开始和结束索引来完成的。这是大多数网站上的实现。

首选哪种方法，为什么？在 GFG 上的实现是否比我的更好。

GFG 实施：

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 arrays 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 into arr[l..r]*/
    i = 0; // Initial index of first subarray 
    j = 0; // Initial index of second subarray 
    k = l; // 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++; 
    } 
} 
  
/* l is for left index and r is right index of the 
   sub-array of arr to be sorted */
void mergeSort(int arr[], int l, int r) 
{ 
    if (l < r) { 
        // Same as (l+r)/2, but avoids overflow for 
        // large l and h 
        int m = l + (r - l) / 2; 
  
        // Sort first and second halves 
        mergeSort(arr, l, m); 
        mergeSort(arr, m + 1, r); 
  
        merge(arr, l, m, r); 
    } 
} 

我的实现：

void Merge(int *L, int *R, int nL, int nR, int *A)
{
    int i, j, k;
    i = j = k = 0;
    while (i < nL && j < nR)
    {
        if (L[i] <= R[j])
        {
            A[k] = L[i];
            i++;
        }
        else
        {
            A[k] = R[j];
            j++;    
        }
        k++;
    }
    while (i < nL)
    {
        A[k] = L[i];
        i++;    
        k++;    
    }
    while (j < nR)
    {
        A[k] = R[j];
        j++;        
        k++;
    }
}

void MergeSort(int *A, int n)
{
    int mid = n / 2;
    if (n < 2)
    {
        return;
    }
    int left[mid], right[n - mid]; 
    for (int i = 0; i < mid; i++)
    {
        left[i] = A[i];
    }
    for (int i = mid; i < n ;i++)
    {
        right[i-mid] = A[i];
    }
    int nL = sizeof(left) / sizeof(int);
    int nR = sizeof(right) / sizeof(int);
    MergeSort(left, nL);
    MergeSort(right, nR);
    Merge(left, right, nL, nR, A);
}

Answer 1

这些实现之间有两个主要区别：

• 在第一个 merge 函数中，r 索引包含在切片中，而在 Merge 中，您传递不同的数组，每个数组都有其大小。将索引传递给最后一个元素在 C 和 C++ 中不是惯用的，因为它需要+1/-1 调整容易出错，并且不允许指定空切片，尤其是在索引类型为无符号时。

• 在第一个实现中，临时数组被分配为 VLA，顺便说一下，这在 C++ 中不是标准的，在 C 中只是可选的，在 merge 函数中，所以在排序过程中使用的最大临时存储量与原始数组的大小相同（最后一次合并）。在第二种实现中，临时存储分配在递归MergeSort 函数中，因此在任何给定点使用的内存量都更大，大约是原始数组大小的两倍。

另一种更保守的方法是使用包含/排除约定，只为合并函数中的左切片分配临时存储，将临时存储需求减少到原始数组大小的 50%。

void merge(int arr[], int l, int m, int r) { 
    int i, j, k; 
    int n1 = m - l; 
  
    /* create temp arrays: should allocate from the heap for large arrays */
    int L[n1]; 
  
    /* Copy data to temp arrays L[] and R[] */
    for (i = 0; i < n1; i++) {
        L[i] = arr[l + i];
    }

    /* Merge the temp arrays back into arr[l...r]*/
    i = 0; // Initial index of first subarray 
    j = l; // Initial index of second subarray 
    k = l; // Initial index of merged subarray 
    while (i < n1 && j < r) { 
        if (L[i] <= arr[j]) { 
            arr[k++] = L[i++]; 
        } else { 
            arr[k++] = arr[j++]; 
        } 
    } 
  
    /* Copy the remaining elements of L[], if there are any */
    while (i < n1) {
        arr[k++] = L[i++];
    }
  
    /* No need to copy the remaining elements of the right slice */
}
  
/* l is for left index and r is the index of the first element beyond the 
   sub-array of arr to be sorted */
void mergeSort(int arr[], int l, int r) { 
    if (r - l >= 2) { 
        // Same as (l+r)/2, but avoids overflow for large l and h 
        int m = l + (r - l) / 2; 
  
        // Sort first and second halves 
        mergeSort(arr, l, m); 
        mergeSort(arr, m, r); 
        merge(arr, l, m, r); 
    } 
}

void arraySort(int arr[], int length) {
    mergeSort(arr, 0, length);
}