[Leetcode] Sort list 对链表进行排序

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

时间复杂度为O(nlogn)，可以想到归并排序、快排、桶排序。

思路：使用归并排序，整体可以分为两体，一、构造两个已排序的子链表；二、将子链表合并。针对第一部分，可以使用快慢指针的方法，分割链表，然后对结点进行递归排序；针对第二部分，取出两子链表的表头结点进行比较大小，小的先放入新链表。针对后面大神们的删除newList的技巧，可以认真的学习。代码如下

/**
 * 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==NULL||head->next==NULL)  
            return head;
        return mergeTwo(head);    
    }

    ListNode *mergeTwo(ListNode *head)
    {
        if(head==NULL|| head->next==NULL)
            return head;
        ListNode *preSlow=NULL;
        ListNode *slow=head,*fast=head;

        while(fast&&fast->next)
        {
            preSlow=slow;
            slow=slow->next;
            fast=fast->next->next;
        }
        preSlow->next=NULL;
        ListNode *left=mergeTwo(head);
        ListNode *right=mergeTwo(slow);
        return megerTwoLists(left,right);
    }

    ListNode *megerTwoLists(ListNode *left,ListNode *right)
    {
        ListNode *newList=new ListNode(-1);
        
        ListNode *pre=newList;
        while(left&&right)
        {
            if(left->val > right->val)
            {
                pre->next=right;
                right=right->next;
            }
            else
            {
                pre->next=left;
                left=left->next;
            }
            pre=pre->next;
        }
        if(left)
            pre->next=left;
        else
            pre->next=right;
        
        //下面是大神们的写法。也可以直接写成return newList->next;但会造成内存泄漏？
        slow=newList->next;
        newList->next=NULL;
        delete newList;

        return slow;
    }
};