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;
    }
};