Sort List

Sort a linked list in O(n log n) time using constant space complexity.

Analyse: When it comes to O(nlogn), we need to think of sort algorithms like merge sort, quick sort, and heap sort. Choosing merge sort, we can reuse the code from merge two sorted lists. 

Runtime: 60ms.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(!head || !head->next) return head;
        
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast->next && fast->next->next){
            fast = fast->next->next;
            slow = slow->next;
        }
        fast = slow->next;
        slow->next = nullptr; //break the list into two parts
        
        return merge2lists(sortList(head), sortList(fast));
    }
    ListNode* merge2lists(ListNode *l1, ListNode *l2) {
        ListNode pre(-1);
        
        for(ListNode* p = ⪯ l1 || l2; p = p->next){
            int val1 = l1 == nullptr ? INT_MAX : l1->val;
            int val2 = l2 == nullptr ? INT_MAX : l2->val;
            
            if(val1 > val2){
                p->next = l2;
                l2 = l2->next;
            }
            else{
                p->next = l1;
                l1 = l1->next;
            }
        }
        return pre.next;
    }
};