哪种合并排序实现是首选的…为什么？ 我在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);
}

void合并（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]这些实现之间有两个主要区别：


<>代码>合并< <代码>函数，在代码中包含 R>代码>索引，而在My/<代码>中，您可以传递不同的数组，每个数组都有其大小。将索引传递到最后一个元素在C和C++中不是惯用的，因为它要求容易出错<代码> + 1代码/代码> />代码> 1代码/代码>调整，不允许指定EMPT。y切片，尤其是索引类型为无符号时


 
在第一次实现中，临时数组被分配为VLAS，在C++中，它不标准，在C代码中只有可选的，在<代码>合并/代码>函数中，因此在排序过程中使用的临时存储量的最大量与原始数组（上次合并）的大小相同。。在第二个实现中，在递归
MergeSort
函数中分配临时存储，因此在任何给定点使用的内存量都更大，大约是原始数组大小的两倍

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);
}



另一种更保守的方法是使用included/excluded约定，只为合并函数中的左片分配临时存储，从而将临时存储需求减少到原始阵列大小的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);
}

void合并（intarr[]，intl，intm，intr）{
int i，j，k；
int n1=m-l；
/*创建临时数组：应该从堆中为大型数组分配*/
int L[n1]；
/*将数据复制到临时数组L[]和R[]*/
对于（i=0；i<代码> > >代码> >：代码分类<：/>代码>从GEEKS实现的是非标准C++（通常），当然不是BTW，你的也不是。请看：是的，我可以使用向量而不是数组。如果我使用向量，vector，sisie（）将给出长度。我的问题是，是否需要像Geeksforgeks实现那样传递开始和结束索引传递开始和结束ID有什么好处吗。@idclev463035818-std:：sort不稳定，merge sort不稳定，所以std:：stable_sort。