LeetCode-Sort List

這個題目比較有意思，因爲平時比較熟悉的排序一般就是對數組操作，題目要求O(n log n)和constant的空間複雜度，能有O(n log n)的算法一般就是merge sort，quick sort或者heap sort，這裏quick sort難以實現因爲核心步驟partion需要雙向的指針，所以quick sort適合雙向鏈表，這裏我用merge sort，一個比較重要的方法就是用O(n)的複雜度找到鏈表中心節點，用的快慢指針即可實現，然後就這樣不停的分解鏈表然後merge，代碼如下：

/**
 * 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* p = head;
        ListNode* q = head;
        ListNode* pre = NULL;
        while(q&&q->next){
            pre = p;
            p = p->next;
            q = q->next->next;
        }
        pre->next = NULL;
        ListNode* left = sortList(head);
        ListNode* right = sortList(p);
        return mergeList(left,right);
    }
    
private:
    static ListNode* mergeList(ListNode* left,ListNode* right){
        ListNode* head = new ListNode(-1);
        ListNode *p = head;
        while(left&&right){
            if(left->val>right->val){
                p->next = right;
                right = right->next;
            }
            else{
                p->next = left;
                left = left->next;
            }
            p = p->next;
        }
        if(left){
            p->next = left;
        }
        if(right){
            p->next = right;
        }
        return head->next;
    }
};