Sort a linked list in O(n log n) time using constant space complexity.
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *merge(ListNode *left, ListNode *right) {
ListNode *temp = new ListNode(0);
ListNode *p = temp;
while(left != NULL && right != NULL) {
if(left->val <= right->val) {
p->next = left;
left = left->next;
}
else {
p->next = right;
right = right->next;
}
p = p->next;
}
if(left != NULL) {
p->next = left;
}
else {
p->next = right;
}
// Free temp
p = temp->next;
temp->next = NULL;
delete temp;
return p;
}
ListNode *mergeSort(ListNode *head) {
if(head == NULL || head->next == NULL) return head;
ListNode *p = head;
ListNode *q = head;
ListNode *pre = NULL;
while(q != NULL && q->next != NULL) {
q = q->next->next;
pre = p;
p = p->next;
}
pre->next =NULL;
ListNode *left = mergeSort(head);
ListNode *right = mergeSort(p);
return merge(left, right);
}
ListNode *sortList(ListNode *head) {
if(head == NULL || head->next == NULL)
return head;
return mergeSort(head);
}
};