sort-list——链表、快慢指针找中间、归并排序

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

链表，快慢指针找中点，归并排序。

注意判断条件fast->next!=NULL&&fast->next->next!=NULL，若为fast!=NULL&&fast->next!=NULL则会出现内存溢出

 /**
  * 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;
         ListNode* slow, *fast;
         slow=head;
         fast=head;
         while(fast->next!=NULL&&fast->next->next!=NULL){
             slow=slow->next;
             fast=fast->next->next;
         }
         fast=slow;
         slow=slow->next;
         fast->next=NULL;
         fast=sortList(head);
         slow=sortList(slow);
         return merge(fast,slow);

     }
     ListNode *merge(ListNode *left, ListNode *right){
         ListNode *res,*temp;
         if(left==NULL){
             res=right;
             return res;
         }
         if(right==NULL){
             res=left;
             return res;
         }
         if(left->val<=right->val){
             res=left;
             left=left->next;
         }else{
             res=right;
             right=right->next;
         }
         temp=res;
         while(left!=NULL&&right!=NULL){
             if(left->val<=right->val){
                 temp->next=left;
                 left=left->next;
             }else{
                 temp->next=right;
                 right=right->next;
             }
             temp=temp->next;

         }
         if(left!=NULL){
             temp->next=left;
         }
         if(right!=NULL){
             temp->next=right;
         }
         return res;
     }
 };