C++ 合并排序无法正常工作

在我的merge-sort方法中，我还有一个merge函数，我相信它在别处测试时工作正常。但是，当我尝试将合并排序作为一个整体时，数字排序不正确。 编辑：添加了合并

代码：

void合并排序（int A[]，int p，int q）
//PRE:p>=0；q>=0；[p..q]已初始化
//POST:A[p..q]按升序排序
{
int i；//用于初始化L和R的计数器
int j；
int m；//A的中点
int L[100]；//A的下半部分
int R[100]；//函数的上半部分
if（p

您的合并步骤始终使用

A[0]

作为合并两个范围的目标。您希望索引

[p..m]

和

[m+1..q]

描述的范围返回到

A[p..q]

。至少有两个简单的修复方法

• 将

  A+p

  作为最后一个参数传递到

  merge

  （或者使用

  &A[p]

  ，它们是相同的）
• 将

  p

  作为附加参数传递到

  merge

  并使用它初始化

  a\u ctr

选择其中一个并测试它

编辑：

我在本地测试了您的代码，发现对

mergeSort

的递归调用应该上移到您计算

m

的行下方。您复制到临时数组的以下行属于合并进程，并且应该在递归调用之后

---

< P> < /P>你是否愿意修复你的缩进：“<代码>合并< /COD> >什么？C++有一个内置的合并，并且在内置的排序中甚至可以合并SoTi尝试所有这些东西，仍然得到相同的结果。

void mergeSort( int A[], int p, int q )
// PRE: p >= 0; q >= 0; A[p..q] is initialized
// POST: A[p..q] is sorted in ascending order
{
    int i;                                     //  counter used to initialize L and R
    int j;
    int m;                                     // midpoint of A
    int L[100];                                // lower half of A
    int R[100];                                // upper half of A

    if ( p < q )                               // if list contains more than one value
    {
        m = ( p + q ) / 2;                     // find midpoint

        j = 0;

        for ( i = p; i <= m; i++ )             // initialize lower half of array
        {
            L[j] = A[i];
            j++;
        }

        j = 0;

        for ( i = m + 1; i <= q; i++ )         // initialize upper half of array
        {
            R[j] = A[i];
            j++;
        } 

        mergeSort( A, p, m );                  // call mergeSort for lower half of array

        mergeSort( A, m + 1, q );              // call mergeSort for upper half of array

        merge( L, R, m - p + 1, q - m, A );    // merge both sides
    }   
}

void merge( int L[], int R[], int l_size, int r_size, int A[] )
// PRE: l_size > 0; r_size > 0; L[0..l_size-1] is in ascending order;
//      R[0..r_size-1] is in ascending order; A is allocated to l_size + r_size
// POST: A[0..l_size+r_size-1] contains all elements of L[0..l_size-1] and          
         R[0..r_size-1]
{
    int i;                                 // counter used to fill A at end of algorithm
    int l_ctr;                             // counter used to traverse L
    int r_ctr;                             // counter used to traverse R
    int a_ctr;                             // counter used to traverse A

    l_ctr = 0;
    r_ctr = 0;                             // set all counters equal to zero
    a_ctr = 0;

    while ( l_ctr < l_size && r_ctr < r_size ) // loop runs until reaching end of a list
    {
        if ( L[l_ctr] < R[r_ctr] )            // if lowest remain ing value in L is
        {                                     // lower than lowest remaining value in R;
            A[a_ctr] = L[l_ctr];              // set next index of A to L[l_ctr]
            l_ctr++;                          // increment l_ctr by one
        }
        else                                       // else do the same for r_ctr
        {
            A[a_ctr] = R[r_ctr];
            r_ctr++;
        }
        a_ctr++;                                   // increment a_ctr by one
    }

    if ( l_ctr < l_size )                          // if all of L has not been seen yet
    {
        for ( i = l_ctr; i < l_size; i++ )         // loop sets remaining values in L
        {                                          // to the last values of A
            A[a_ctr] = L[i];
            a_ctr++;
        }
    }
    else                                           // else do the same for R
    {
        for ( i = r_ctr; i < r_size; i++ )
        {
            A[a_ctr] = R[i];
            a_ctr++;
        }
    }
}