LeetCode OJ：Sort List（排序链表）

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

题目要求在常数控件内以O(nlogn)的事件复杂度来排序链表。

常数空间内我没有实现，O(nlogn)的话使用归并排序就可以了吗， 下面是代码：

/**
 * 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;
        return mergeSort(head);
    }

    ListNode * mergeSort(ListNode * head)
    {
        if(head == NULL || head->next == NULL) return head;
        ListNode * fastP = head;
        ListNode * slowP = head;
        ListNode * slowPre = slowP; //这里生成快慢指针的时候应该注意一点，选一个pre节点，否则直接用slowP的话那么分成的两段是不平衡的
        for(; fastP != NULL && fastP->next != NULL; fastP = fastP->next->next, slowP = slowP->next){
            slowPre = slowP;
        }
        ListNode * head1 = head;
        ListNode * head2 = slowP;
        slowPre->next = NULL;//截断list
        head1 = mergeSort(head1);
        head2 = mergeSort(head2);
        return merge(head1, head2);
    }

    ListNode * merge(ListNode * head1, ListNode * head2)
    {
        ListNode * ret = new ListNode(0);   //记录首节点的位置
        ListNode * helper = ret;    //这里应该注意，helper是用来标记下一个插入位置用的。
        while(head1 && head2){
            if(head1->val < head2->val){
                helper->next = head1;
                head1 = head1->next;
            }else{
                helper->next = head2;
                head2 = head2->next;
            }
            helper = helper->next;//指向当前链表的尾节点
        }
        if(head1 == NULL)
                helper->next = head2;
             else 
                helper->next = head1;
        helper = ret->next;
        ret->next = NULL;  //销毁helper节点
        delete ret;
        return helper;
    }

};

 下面的事java版，写了很多的局部变量，主要事图个方便啊，方法与上相同，可以满足题目的限制条件。代码如下所示：

public class Solution {
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null)
            return head;
        return mergeSort(head);
    }

    public ListNode mergeSort(ListNode head){
        if(head == null || head.next == null) return head;
        ListNode fast = head;
        ListNode slow = head;
        ListNode slowPre = new ListNode(-1);
        slowPre.next = head;
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
            slowPre = slowPre.next;
            if(fast != null)
                fast = fast.next;
        }
        ListNode list1 = head;
        ListNode list2 = slow;
        slowPre.next = null;
        list1 = mergeSort(list1);
        list2 = mergeSort(list2);
        return merge(list1, list2);
    }
    
    public ListNode merge(ListNode head1, ListNode head2){
        if(head1 == null) return head2;
        if(head2 == null) return head1;
        ListNode helperP = new ListNode(-1);
        helperP.next = head1;
        ListNode pPre = helperP;
        ListNode p = head1;
        ListNode helperQ = new ListNode(-1);
        helperQ.next = head2;
        ListNode qPre = helperQ;
        ListNode q = head2;
        while(p != null && q != null){
            if(p.val < q.val){
                p=p.next;
                pPre = pPre.next;
            }else{
                pPre.next = q;
                qPre.next = q.next;
                q.next = p;
                q = qPre.next;
                pPre = pPre.next;
            }
        }
        if(p == null){
            pPre.next = helperQ.next;
            helperQ.next = null;
        }
        return helperP.next;
    }
}