148. Sort List（快排、归并）

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

首先给出快排解法：

class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(head == NULL)
            return NULL;
        quick_sort(&head, NULL);
        return head;
    }
    void quick_sort(ListNode** head, ListNode* end){
        if(*head == end)
            return ;

        ListNode *right = NULL;
        ListNode *pivot = *head;
        ListNode **left_walk = head;
        ListNode **right_walk = &right;

        for(ListNode* old=(*head)->next; old!=end; old=old->next){
            if(old->val < pivot->val){
                *left_walk = old;
                left_walk = &(old->next);
            }
            else{
                *right_walk = old;
                right_walk = &(old->next);
            }
        }

        *right_walk = end; //这个顺序不能放在下面，因为要*right_walk有可能就是right，必须先更新right，在最后只剩下一个元素的情况下，这样可以保证*head==end，成功返回
        *left_walk = pivot;
        pivot->next =right;

        quick_sort(&(pivot->next), end);
        quick_sort(head, pivot);
    }
};

快排使用二级指针很方便，所以尽量用二级指针。

下面是归并，先给一个使用dummy的版本：

class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(head == NULL || head->next == NULL)
            return head;

        ListNode* slow = head;
        //fast必须从next开始，因为是归并。而且这不是求链表入环点，不必do-while那么严格的要求
        //如果不是head->next，那么如果链表为[2,1]两个元素，
        //会陷入死循环，每次fast最终传入merge都为NULL，链表长度没变
        ListNode* fast = head->next; 

        while(fast != NULL && fast->next != NULL){
            slow = slow->next;
            fast = fast->next->next;
        }

        fast = slow->next;
        slow->next = NULL;

        return merge(sortList(head), sortList(fast));
    }
    ListNode* merge(ListNode* node1, ListNode* node2){
        ListNode* dummy = new ListNode(-1);
        ListNode* tmp = dummy;
        while(node1 != NULL && node2 != NULL){
            if(node1->val < node2->val){
                tmp->next = node1;
                node1 = node1->next;
            }
            else{
                tmp->next = node2;
                node2 = node2->next;
            }
            tmp = tmp->next;
        }

        if(node1 != NULL)   //注意不要忘了后续链表
            tmp->next = node1;
        else
            tmp->next = node2;

        return dummy->next;
    }
};

如果不使用dummy，合并两个排序链表有传统的套路，就是下面的递归方法：

    ListNode* merge(ListNode* node1, ListNode* node2){
        if(node1 == NULL)
            return node2;
        else if(node2 == NULL)
            return node1;

        ListNode* res = NULL;
        if(node1->val < node2->val){
            res = node1;
            res->next = merge(node1->next, node2);
        }
        else{
            res = node2;
            res->next = merge(node1, node2->next);
        }
        return res;
    }

一日后更新：哈哈，经过这两天的刷题，又掌握了一种新的merge方法：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* head = NULL;
        ListNode** pp = &head;

        while(l1 != NULL && l2 != NULL){
            if(l1->val < l2->val){
                *pp = l1;
                pp = &(l1->next);
                l1 = l1->next;
            }
            else{
                *pp = l2;
                pp = &(l2->next);
                l2 = l2->next;
            }
        }

        if(l1 != NULL)
            *pp = l1;
        else
            *pp = l2;

        return head;
    }
};