用归并排序对链表进行排序

1) If head is NULL or there is only one element in the Linked List
then return.
2) Else divide the linked list into two halves.
FrontBackSplit(head, &a, &b); /* a and b are two halves */
3) Sort the two halves a and b.
MergeSort(a);
MergeSort(b);
4) Merge the sorted a and b (using SortedMerge() discussed here)
and update the head pointer using headRef.
*headRef = SortedMerge(a, b);

#include <stdio.h>
#include <stdlib.h>

/*Link list node*/
struct node
{
int data;
struct node* next;
};

/*function prototype */
struct node* SortedMerge(struct node* a, struct node* b);
void FrontBackSplit(struct node* source, struct node** frontRef, struct node** backRef);

/*sorts the linked list by changing next pointers(not data) */
void 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;
}

/*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);
}

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 recur */
if(a->data <= b->data)
{
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 references parameters.
If the length is odd, the extra node shold 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;

if(source == NULL || source->next == NULL)
{
*frontRef = source;
*backRef = NULL;
}
else
{
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;
}
}

*frontRef = source;
*backRef = slow->next;
slow->next = NULL;
}
}

时间复杂度为O(nLogn)。

貌似MergeSort的时间复杂度为O(nLogn)，Split的时间复杂度也为O(nLogn)？当然了，总的时间复杂度还是O(nLogn)，但是肯定没有对数组进行归并排序快