[leetcode]Sort List

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

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

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

        ListNode * a = sortList(head);
        ListNode * b = sortList(mid);
        return merge(a,b);
    }
    ListNode *merge(ListNode *head,ListNode *slow){
        if(head == NULL) return slow;
        if(slow == NULL) return head;
        ListNode *ans ;
        ListNode *res ;
        if(head->val < slow->val){
            ans = head;
            head = head ->next;
        }
        else {
            ans = slow;
            slow = slow ->next;
        }
        res = ans;
        while(head !=NULL && slow !=NULL){
            if(head->val<slow->val){
                ans->next = head;
                head = head -> next;
            }
            else{
                ans -> next = slow;
                slow = slow -> next;
            }
            ans = ans->next;
        }
        if(head !=NULL) ans->next = head;
        if(slow !=NULL) ans->next = slow;

        return res;
    }


};