Merge sort code for linked list only sorting half the elements in C

Question

I have some code to merge sort a linked list that contains strings as the data value. My goal is to sort the nodes in the linked list in alphabetical order.

Here is how I am defining my nodes:

struct Node { 
    void *data; 
    struct Node* next; 
}; 

And this is the call that I am making to sort the list in my main:

int main() 
{ 

    struct Node* a = NULL; 
    struct Node* sorted = NULL;

    push(&a, "orange"); 
    push(&a, "banana"); 
    push(&a, "strawberry"); 
    push(&a, "apple"); 
    push(&a, "kiwi"); 
    push(&a, "grapes"); 

    sorted = MergeSort(a); 

    printf("Sorted Linked List is: \n"); 
    printList(sorted); 

    return 0; 
} 

The push function inserts an element to the start of a linked list, while the printList function will print each element in the list followed by a newline.

I can confirm that the push and printList functions are working properly as all the elements of the list a are printed as expected when I test that.

Here is the code I am using to sort the list in alphabetical order:

/* sorts the linked list by changing next pointers (not data) */
struct Node* MergeSort(struct Node* headRef) 
{ 
    struct Node* head = headRef; 
    struct Node* a; 
    struct Node* b; 

    /* Base case -- length 0 or 1 */
    if ((head == NULL) || (head->next == NULL)) { 
        return headRef; 
    } 

    /* Split head into 'a' and 'b' sublists */
    FrontBackSplit(head, &a, &b); 

    /* Recursively sort the sublists */
    MergeSort(a); 
    MergeSort(b); 

    /* answer = merge the two sorted lists together */
    headRef = SortedMerge(a, b); 
    return headRef;
} 


struct Node* SortedMerge(struct Node* a, struct Node* b) 
{ 
    struct Node* result = NULL; 

    /* Base cases */
    if (a == NULL) 
        return (b); 
    else if (b == NULL) 
        return (a); 

    /* Pick either a or b, and recur */
    if (strcmp(a->data, b->data) <= 0) { 
        result = a; 
        result->next = SortedMerge(a->next, b); 
    } 
    else { 
        result = b; 
        result->next = SortedMerge(a, b->next); 
    } 
    return (result); 
} 

/* UTILITY FUNCTIONS */
/* Split the nodes of the given list into front and back halves, 
    and return the two lists using the reference parameters. 
    If the length is odd, the extra node should go in the front list. 
    Uses the fast/slow pointer strategy. */
void FrontBackSplit(struct Node* source, 
                    struct Node** frontRef, struct Node** backRef) 
{ 
    struct Node* fast; 
    struct Node* slow; 
    slow = source; 
    fast = source->next; 

    /* Advance 'fast' two nodes, and advance 'slow' one node */
    while (fast != NULL) { 
        fast = fast->next; 
        if (fast != NULL) { 
            slow = slow->next; 
            fast = fast->next; 
        } 
    } 

    /* 'slow' is before the midpoint in the list, so split it in two 
    at that point. */
    *frontRef = source; 
    *backRef = slow->next; 
    slow->next = NULL; 
} 

When I print the list sorted after the sorting process, my output looks like this:

Sorted Linked List is: 
grapes
kiwi
strawberry

Which shows that the sorting is working properly, however not all of the elements are being outputted. I was wondering why this might be the case?

Answer 1

/* Recursively sort the sublists */
MergeSort(a); 
MergeSort(b); 

Here is the faulty part. You are sorting the sub-lists, but after having sorted them, you are not updating a and b to point to the corresponding new heads of the lists.

Change to

/* Recursively sort the sublists */
a = MergeSort(a); 
b = MergeSort(b); 

and it behaves as expected.