【leetcode】Sort List

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

 

class Solution {
public:
    ListNode *sortList(ListNode *head)
    {
        if(!head||!head->next) return head;
        return mergeSort(head);
    }
    ListNode* mergeSort(ListNode* head) {
        if(head==NULL||head->next==NULL) return head;

        ListNode *p=head;
        ListNode *q=head;
        ListNode *pre=NULL;

        while(q&&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 *merge(ListNode *left,ListNode *right)
    {
        ListNode *tmp=new ListNode(0);
        ListNode *p=tmp;
        while(left&&right)
        {
            if(left->val<=right->val)
            {
                p->next=left;
                left=left->next;
            }else
            {
                p->next=right;
                right=right->next;
            }

            p=p->next;
        }

            if(!left)
                p->next=right;
            else
                p->next=left;

            p=tmp->next;
            tmp->next=NULL;
            delete tmp;
            return p;
        }
    
};