[LeetCode] 148. Sort List 解题思路

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

问题：对一个单列表排序，要求时间复杂度为 O(n*logn)，额外空间为 O(1)。

O(n*logn) 时间排序算法，无法是 quick sort, merge sort, head sort。quick sort 需要灵活访问前后元素，适合于数组，merge sort 只需要从左到右扫过去即可，可用于列表结构。

• 当列表元素个数大于2时，将列表拆分为左右对半的两个子列表，对左右子列表分别排序，然后合并。
• 当列表元素个数小于等于2 时，直接对列表元素比较排序。

第一步中的合并操作，实际上另一个LeetCode题目 Merge Two Sorted Lists

需要注意的是，由于是单向列表，为了方便操作元素位置，每次比较操作比较的是指针的下一个元素，详情见 sortmerge 函数。

    /**
     * p 表示父节点
     * ll, lr 分别表示左半列表的父节点，右半列表的父节点
     *
     */
    ListNode* sortmerge(ListNode* p, int len){
        
        if (len <= 1) {
            return p;
        }
        
        if (len == 2) {
            if (p->next->val > p->next->next->val) {
                int tmp = p->next->val;
                p->next->val = p->next->next->val;
                p->next->next->val = tmp;
            }
            return p;
        }
        
        int lenL = len / 2;
        int lenR = len - lenL;
        
        ListNode* ll = p;

        ll = sortmerge(ll, lenL);
        
        ListNode* lr = p;
        
        for (int i = 0 ; i < lenL; i++) {
            lr = lr->next;
        }
        
        lr = sortmerge(lr, lenR);
        

        while (ll != lr && lenR > 0) {
            if (ll->next->val <= lr->next->val) {
                ll = ll->next;
            }else{
                ListNode* next2 = lr->next;
                lr->next = lr->next->next;
                next2->next = ll->next;
                ll->next = next2;
                lenR--;
            }
        }
        
        return p;
    }

    ListNode* sortList(ListNode* head) {
     
        
        ListNode* node = head;
        
        int cnt = 0;
        while (node != NULL) {
            cnt++;
            node = node->next;
        }
        
        ListNode* p = new ListNode(0);
        p->next = head;
        
        p = sortmerge(p, cnt);
        
        head = p->next;
        
        return head;
    }

参考资料：

[LeetCode] Sort List, Solution, 水中的鱼