Question

Compiler threw a SIGSEGV at tmp = pow(p[i],j); while p[i] and j are two integers, and p[i] is a valid element of array p, I really don’t know why…

Original code is here:http://pastebin.com/DYhGeHxm

Answer 1

Has it occurred to you that this:

int i,j,p[2000], a[5000000],num,count,tmp;

may be pushing you either very near, or outright over the brink of your stack space? That is

4 + 4 + 8000 + 20000000 + 4 + 4 + 4

bytes

I.e. you have a 19.08 megabyte stack space declaration. Consider dynamically allocating a at least. When i changed it to be:

int *a = malloc(5000000 * sizeof(*a));

and reran the code, it made it well past the seg-fault you have. unfortunately, it died at this location:

count = 0;
for(i = 0; i < num; i++) {
    for(j = 2; ;j++) {
        tmp = pow(p[i],j);
        if(tmp > 5000000) break;
        a[count++] = tmp; // <=== faulted here, count was 5000193
    }
}

Both loops should break when you reach the allocated max size of a[]. I did the following. At the top of main():

static const int a_max = 5000000;
int *a = malloc(a_max*sizeof(*a));

Down in the loop:

count = 0;
for(i = 0; i < num && count < a_max; i++)
{
    for(j = 2; count < a_max; j++)
    {
        tmp = pow(p[i],j);
        if(tmp > 5000000)
            break;
        a[count++] = tmp;
    }
}

This gets you past all the setup. The last thing is the quicksort algorithm itself, which appears broken as well. I highly advise starting with smaller data sizes to debug that.

Best of luck.

---

EDIT In case you needed a reference quicksort algorithm, i had one sitting in a source file in one of my junk folders. No guarantees its even right (pretty sure it is, and skips length-1 sorts too), but I know it doesn’t hang, so it has that going for it =P

// quicksort for ints
static void quicksort_ints(int *arr, int left, int right)
{
    int p = (left+right)/2;    // as good as any
    int l = left, r = right;   // movable indicies

    while (l <= r)
    {
        while (arr[l] < arr[p])
            ++l;
        while (arr[r] > arr[p])
            --r;
        if (l <= r)
        {
            int tmp = arr[l];
            arr[l] = arr[r];
            arr[r] = tmp;
            ++l;
            --r;
        }
    }

    if (left < r)
        quicksort_ints(arr, left, r);
    if (l < right)
        quicksort_ints(arr, l, right);
}