leetcode hot100

148. 排序链表

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

示例 1:

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

示例 2:

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

思路一：递归 + 归并

思路参考：https://leetcode-cn.com/problems/sort-list/solution/sort-list-gui-bing-pai-xu-lian-biao-by-jyd/

使用递归归并排序

快慢指针找到链表中点后分割链表为左右两段，递归分割左右链表，然后合并两个链表，返回合并后的结果

class Solution {
    public ListNode sortList(ListNode head) {

        // 使用递归归并排序
        if(head == null || head.next == null){
            return head;
        }

        // 快慢指针找到链表中点后分割链表为左右两段
        ListNode slow = head, fast = head.next;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode tmp = slow.next;   // 第二段链表，前面的作为第一段链表
        slow.next = null;           // 第一段链表和第二段链表断开连接

        // 递归分割左右链表
        ListNode left = sortList(head);
        ListNode right = sortList(tmp);

        ListNode res = new ListNode();  // 定义一个空节点，简化合并操作
        ListNode cur = res;             // 
        // 合并两个链表
        while(left != null && right != null){
            if(left.val < right.val){
                cur.next = left;
                left = left.next;
            }else{
                cur.next = right;
                right = right.next;
            }
            cur = cur.next;
        }
        cur.next = left == null ? right : left;
        return res.next;
    }
}

leetcode 执行用时：3 ms > 98.99%, 内存消耗：40.9 MB > 66.19%

复杂度分析：

时间复杂度：归并排序的时间复杂度为O(nlogn), 虽然多了一个遍历链表找中点的操作，但是对于同一层的链表，复杂度为O(n), 递归深度为O(logn), 所以时间复杂度为O(nlogn)

空间复杂度：没有借助额外的容器，但是递归本身需要一个递归栈，栈的深度为O(nlogn), 所以空间复杂度为O(nlogn)

思路二：迭代 + 归并

思路参考：https://leetcode-cn.com/problems/sort-list/comments/

虽然上面解法通过了测试，但是其实是不符合题意的，因为题目要求空间复杂度为O(1), 但是我们使用递归后空间复杂度明显不是O(1),所以需要把递归方式改成迭代方式。

class Solution {
    public ListNode sortList(ListNode head) {
        // 非递归归并排序
        
        // 先统计链表长度
        ListNode tmp = new ListNode();
        tmp.next = head;
        ListNode p = head;
        int length = 0;
        while(p != null){
            p = p.next;
            length++;
        }

        // 主循环，控制每次归并的链表的大小，从1-n/2,成倍扩大
        for(int size = 1; size < length; size <<= 1){
            ListNode cur = tmp.next;
            ListNode tail = tmp;    // 简化连接

            while(cur != null){
                // 从链表中取下固定大小的结点，取两段
                ListNode left = cur;
                ListNode right = cut(left, size);
                cur = cut(right, size);             // 更新cur指针的位置
                // 归并这两段

                tail.next = mergeList(left, right);

                // 把归并后的结果挂到有序链表尾部
                while(tail.next != null){
                    tail = tail.next;
                }
            }
        }
        return tmp.next;
    }

    // 从链表中取下固定大小的结点
    public ListNode cut(ListNode head, int n){
        ListNode p = head;
        // 先跳过n个结点
        while(--n != 0 && p != null){
            p = p.next;
        }
        if(p == null){
            return p;
        }
        ListNode next = p.next;
        // 返回跳过size个结点的指针
        p.next = null;
        return next;
    }

    // 合并两个链表
    public ListNode mergeList(ListNode left, ListNode right){
        ListNode res = new ListNode();
        ListNode cur = res;
        while(left != null && right != null){
            if(left.val < right.val){
                cur.next = left;
                left = left.next;
            }else{
                cur.next = right;
                right = right.next;
            }
            cur = cur.next;
        }
        cur.next = (left != null ? left : right);
        return res.next;
    }
}

希望同学们能把双路归并和 cut 断链的代码烂记于心，以后看到类似的题目能够刷到手软。

leetcode执行用时：7 ms > 27.29%, 内存消耗：40.9 MB > 63.86%

复杂度分析：

时间复杂度：这个就是标准的归并排序，所以时间复杂度为O(nlogn)

空间复杂度：没有借用集合，有没有借用递归，所以复杂度为O(1)