合并排序导致堆栈溢出？

Question

I wrote mergesort() in C++ for linked lists. The issue is that my professor has provided test code with a very large list (length of 575,000). This causes a stack overflow error for my function since it is written recursively.

So it's possible my professor expects us to write it using iterations instead of recursion. I wanted to ask if there is anything wrong with my code that may be causing the stack to overflow?

My code:

typedef struct listnode {
    struct listnode * next;
    long value; 
} LNode;

LNode* mergesort(LNode* data) {
    if(data == NULL || data->next == NULL) {
        return data;
    }else {
        LNode* s = split(data);

        LNode* firstSortedHalf = mergesort(data);
        LNode* secondSortedHalf = mergesort(s);

        LNode* r = merge(firstSortedHalf, secondSortedHalf);
        return r;
    }
}

LNode* split(LNode* list) {
    if(list) {
        LNode* out = list->next;

        if(out) {
            list->next = out->next;
            out->next = split(out->next);
        }
        return out;
    }else {
        return NULL;
    }
}

LNode* merge(LNode* a, LNode* b) {
    if(a == NULL)
        return b;
    else if(b == NULL)
        return a;

    if(a->value < b->value) {
        a->next = merge(a->next,b);
        return a;
    }else {
        b->next = merge(a, b->next);
        return b;
    }
}

Answer 1

So you have three recursive functions. Let's look at the maximum depth of each with the worst case of a list of 575000 elements:

• merge(): This looks to iterate over the entire list. So 575000 stack frames.
• split(): This looks to iterate over the entire list in pairs. So ~250000 stack frames.
• mergesort(): This looks to iterate in a splitting fashion. So log_2(575000) or about 20 stack frames.

So, when we run our programs, we're given a limited amount of stack space to fit all of our stack frames. On my computer, the default limit is about 10 megabytes.

A rough estimate would be that each of your stack frames takes up 32 bytes. For the case of merge() , this means that it would take up about 18 megabytes of space, which is well beyond our limit.

The mergesort() call itself though, is only 20 iterations. That should fit under any reasonable limit.

Therefore, my takeaway is that merge() and split() should not be implemented in a recursive manner (unless that manner is tail recursive and optimizations are on).

Answer 2

A bit late, but it's the recursive merge() that is causing stack overflow. The recursive split() is not an issue, because its maximum depth is log2(n).

So only merge() needs to be converted to iteration.

As commented a long time ago, a bottom up approach using a small (25 to 32) array of pointers is simpler and faster, but I wasn't sure it this would be an issue with getting too much help for the assignment. Link to wiki pseudo-code:

http://en.wikipedia.org/wiki/Merge_sort#Bottom-up_implementation_using_lists

Link to working C example:

http://code.geeksforgeeks.org/Mcr1Bf