LeetCode 148：Sort List

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

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4
Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5

C++
ListNode* sortList(ListNode* head) {
       return mergesort(head);
    }
    ListNode* merge(ListNode* head1,ListNode* head2)
    {
        if(head1 == nullptr)
            return head2;
        else if(head2 == nullptr)
            return head1;
        ListNode* head;
        ListNode* dummy;
        if(head1->val < head2->val)
        {
            head = head1;
            head1 = head1->next;
        }
        else
        {
            head = head2;
            head2 = head2->next;
        }
        dummy = head;
        while(head1 != nullptr&&head2 != nullptr)
        {
            if(head1->val < head2->val)
            {
                head->next = head1;
                head1 = head1->next;
            }
            else
            {
                head->next = head2;
                head2 = head2->next;
            }
            head = head->next;
        }
        if(head1)head->next = head1;
        if(head2)head->next = head2;
        return dummy;
    }
    ListNode* mergesort(ListNode* head)
    {
        if(head == nullptr||head->next == nullptr)
            return head;
        ListNode* slow = head;
        ListNode* fast = head->next;
        while(slow&&fast&&fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode* head1 = head;
        ListNode* head2 = slow->next;
        slow->next = nullptr;
        ListNode* l1 = mergesort(head1);
        ListNode* l2 = mergesort(head2);
        return merge(l1,l2);
    }