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();   //记录首节点的位置
         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;
     }
 }