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; } }