【Leetcode】P148 排序链表

Leetcode P148 排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例1:

输入: 4->2->1->3
输出: 1->2->3->4

示例2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

nlgn的时间复杂度容易实现，归并就可以了。但通常我们的归并排序都是用递归实现，是存在$O(\log n)$的空间复杂度的。所以要实现常数空间复杂度，只能用迭代法。

迭代实现归并的主要思路其实和递归差不多，从size=1的子数组开始，然后size=2，4…每次处理其实都是一个合并的过程。主要就是如何处理size大小的链表，并处理掉边界情况？
代码的注释大概解释了这个过程：

• 主函数递增size，merge函数合并两个有序链表，cut负责从head提取size大小(如果不够，就提取到tail为止)
• merge和cut比较基础，其中merge返回合并之后的头，cut返回切割之后剩下部分的头
• 维护一个tail，负责接上新拆下来的l和r
• dummy的技巧就不多说了，很常见

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(!head || !head->next) return head;
        int n = 1;
        ListNode* cur = head;
        while(cur->next) {
            cur = cur->next;
            n++;
        }
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        for(int size = 1; size < n; size *= 2) {
            cur = dummy->next;
            ListNode* tail = dummy;
            while(cur) {
                ListNode* l = cur;
                ListNode* r = cut(l, size);
                cur = cut(r, size);
                tail->next = merge(l, r);
                while(tail->next) {
                    tail = tail->next;
                }
            }
        }
        return dummy->next;
    }
    
    ListNode* merge(ListNode* l, ListNode* r) {
        ListNode* dummy = new ListNode(-1);
        ListNode* p = dummy, *p1 = l, *p2 = r;
        while(p1 && p2) {
            if(p1->val < p2->val) {
                p->next = p1;
                p1 = p1->next;
            } else {
                p->next = p2;
                p2 = p2->next;
            }
            p = p->next;
        }
        if(p1) p->next = p1;
        if(p2) p->next = p2;
        return dummy->next;
    }

    ListNode* cut(ListNode* head, int size) {
        ListNode* cur = head;
        while(--size) {
            if(cur) cur = cur->next;
            else break;
        }
        if(!cur) return NULL;
        ListNode* res = cur->next;
        cur->next = NULL;
        return res;
    }
};