递归合并排序，大型数组的分段错误

Question

I have implemented the merge sort recursively. It works up to a certain size of the sorted array then it crashes with "segmentation fault". At the Intel Xeon, 16GB, the maximum float array size is 17352, higher for int array, lower for double array. At the AMD A10, 16GB, the limit is 2068 for floats. Clearly there is a memory issue. Other sorting algorithms I did for arrays (non recursively) work fine for up to ~2e6. The compiler is GCC 4.4.7. How do I improve this merge sort so it works for the bigger arrays?

#include <iostream>
#include <stdlib.h>
#include <cmath>
#include <vector>
using namespace std;

// --------------------------------------------------------
// merge 2 subarrays of 1 array around its middle im
template <class C>
void merge(C* arr, int ilow, int imid, int ihigh)
{
vector<C> temp; // array seg faults earlier than vector
for(int i=ilow; i<=ihigh; i++) temp.push_back(arr[i]); // copy array

int i1=ilow, i2=imid+1, ai=ilow; // starting positions

while(i1<=imid && i2<=ihigh) // compare 1st and 2nd halves
{
    if(temp[i1]<=arr[i2])
    {
        arr[ai] = temp[i1];
        i1++; // leave smaller val behind
    }
    else
    {
        arr[ai] = temp[i2];
        i2++; // leave smaller val behind
    }
    ai++; // move forward
}

if(i2>ihigh) while(i1<=imid) // if 2nd is done, copy the rest from 1st
{
    arr[ai] = temp[i1];
    i1++;
    ai++;
}

if(i1>imid) while(i2<=ihigh) // if 1st is done, copy the rest from 2nd
{
    arr[ai] = temp[i2];
    i2++;
    ai++;
}

} // merge()



// --------------------------------------------------------
// merge sort algorithm for arrays
template <class C>
void sort_merge(C* arr, int ilow, int ihigh)
{

if(ilow < ihigh)
{
    int imid = (ilow+ihigh)/2; // get middle point
    sort_merge(arr, ilow,   imid); // do 1st half
    sort_merge(arr, imid+1, ihigh); // do 2nd half
    merge(arr, ilow, imid, ihigh); // merge 1st and 2nd halves
}

return;
} // sort_merge()



///////////////////////////////////////////////////////////
int main(int argc, char *argv[])
{
// crashes at 17353 on Intel Xeon, and at 2069 on AMD A10, both 16Gb of ram
const int N=17352+0;
float arr[N]; // with arr[double] crashes sooner, with arr[int] crashes later

// fill array
for(long int i=0; i<N; i++)
{
    //arr[i] = rand()*1.0/RAND_MAX; // random
    arr[i] = sin(i*10)+cos(i*10); // partially sorted
    //arr[i] = i; // sorted
    //arr[i] = -i; // reversed
}

sort_merge(arr, 0, N-1);

return 0;
}

Answer 1

Consider the way you are copying the array:

vector<C> temp; // array seg faults earlier than vector
for(int i=ilow; i<=ihigh; i++) temp.push_back(arr[i]); // copy array

When this completes, temp contains ihigh - ilow + 1 values, which are accessible from temp[0] to temp[ihigh - ilow] . This means all values in temp are offset by -ilow compared to arr .

However the rest of your code accesses temp with the indices of the source array, for example:

if(temp[i1]<=arr[i2]) // i1 isn't a valid index into temp, should be (i1 - ilow)

Hence the crash. When using the proper offset into temp your code seems to work correctly .

Answer 2

The following, all by itself, is enough to cause a segmentation fault if N is large enough, due to the notorious stack overflow . If not, filling the array should.

int main(int argc, char *argv[])
{
    // crashes at 17353 on Intel Xeon, and at 2069 on AMD A10, both 16Gb of ram
    const int N=17352+0;
    float arr[N];
}

The reason is that local variables tend to be allocated on the stack, but the stack is limited in size and not designed for massive memory allocations. If you instead did

float *arr = new arr[N]; // probably should be unique_ptr instead....

or

std::vector<float> arr(N);

you wouldn't have any problems, since both of these methods allocate memory on the heap.