void doMergeSort(T arr[], int start, int end) {
if (start == end)
return;
//Recursive call
int middle = (start + end) / 2;
doMergeSort(arr, start, middle);
doMergeSort(arr, middle + 1, end);
//Merge operation
int i = start;
int j = middle + 1;
int k = 0;
int size = end - start + 1;
T *temp = new T[size];
while (k < size) {
if (j > end || (i <= middle && arr[i] < arr[j]))
temp[k++] = arr[i++];
else
temp[k++] = arr[j++];
}
for (i = 0; i < size; i++)
arr[start + i] = temp[i];
delete[] temp;
}
static listnode_t *doMergeSort(listnode_t *list, comparefunc funcCompare)
{
listnode_t *p;
if(list->next)
{
p = splitList(list);
// Sort both halves and merge them back.
list = mergeLists(doMergeSort(list, funcCompare),
doMergeSort(p, funcCompare), funcCompare);
}
return list;
}
Solution::ListNode* Solution::sortListMerge(Solution::ListNode* head)
{
int ListSize=0;
ListNode* TempPointer=head;
while (TempPointer)
{
ListSize++;
TempPointer=TempPointer->next;
}
if (ListSize<2)
{
return head;
}
else
{
return doMergeSort(head, ListSize);
}
}
static void mergeSort(LinkList *list)
{
if(list->state->numElements > 1)
{
listnode_t *n, *last;
if(list->state->flags & LCF_CIRCULAR)
{ // Break the ring so we can sort more easily.
list->tailptr->next = NULL;
list->headptr->prev = NULL;
}
list->headptr = doMergeSort(list->headptr, list->funcCompare);
// Only singly linked atm, we need to be doubly linked.
last = list->headptr;
n = last->next;
do
{
n->prev = last;
last = n;
n = n->next;
} while(n != NULL);
list->tailptr = last;
// Circularly linked?
if(list->state->flags & LCF_CIRCULAR)
{ // Link the ring back.
list->tailptr->next = list->headptr;
list->headptr->prev = list->tailptr;
}
else
{
list->tailptr->next = NULL;
list->headptr->prev = NULL;
}
}
}
int main(void){
doMergeSort(100000);
return 0;
}
void mergeSort(T arr[], int size) { doMergeSort(arr, 0, size - 1); }
Solution::ListNode* Solution::doMergeSort(Solution::ListNode* Pointer2Head, int ListSize)
{
if (ListSize>1)
{
int FrontSize=ListSize/2;
int BackSize=ListSize-FrontSize;
ListNode* Pointer2Front=Pointer2Head;
ListNode* Pointer2Back=Pointer2Head;
ListNode* Pointer2Result=NULL;
ListNode* Pointer2ResultRear=NULL;
ListNode* TempPointer=NULL;
for (int Counter=FrontSize; Counter>0; Counter--)
{
TempPointer=Pointer2Back;
Pointer2Back=Pointer2Back->next;
}
TempPointer->next=NULL;
Pointer2Front=doMergeSort(Pointer2Front, FrontSize);
Pointer2Back=doMergeSort(Pointer2Back, BackSize);
for (int Counter=0; Pointer2Back&&Pointer2Front; Counter++)
{
if (Counter==0)
{
if (Pointer2Front->val>Pointer2Back->val)
{
Pointer2Result=Pointer2Back;
Pointer2ResultRear=Pointer2Back;
Pointer2Back=Pointer2Back->next;
Pointer2ResultRear->next=NULL;
}
else
{
Pointer2Result=Pointer2Front;
Pointer2ResultRear=Pointer2Front;
Pointer2Front=Pointer2Front->next;
Pointer2ResultRear->next=NULL;
}
}
else
{
if (Pointer2Front->val>Pointer2Back->val)
{
Pointer2ResultRear->next=Pointer2Back;
Pointer2Back=Pointer2Back->next;
Pointer2ResultRear=Pointer2ResultRear->next;
Pointer2ResultRear->next=NULL;
}
else
{
Pointer2ResultRear->next=Pointer2Front;
Pointer2Front=Pointer2Front->next;
Pointer2ResultRear=Pointer2ResultRear->next;
Pointer2ResultRear->next=NULL;
}
}
}
if (Pointer2Front)
{
Pointer2ResultRear->next=Pointer2Front;
}
else if(Pointer2Back)
{
Pointer2ResultRear->next=Pointer2Back;
}
return Pointer2Result;
}
else
{
return Pointer2Head;
}
}
