【字节专题】leetcode 148. 排序链表

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

归并排序（自底向上）

重点在于分别以1，2，4，8…的步长遍历链表，然后一步步merge

题目要求时间空间复杂度分别为O(nlogn)和O(1)，根据时间复杂度我们自然想到二分法，从而联想到归并排序；
对数组做归并排序的空间复杂度为 O(n)，分别由新开辟数组O(n)和递归函数调用O(logn)组成，而根据链表特性：

• 数组额外空间：链表可以通过修改引用来更改节点顺序，无需像数组一样开辟额外空间；
• 递归额外空间：递归调用函数将带来O(logn)的空间复杂度，因此若希望达到O(1)空间复杂度，则不能使用递归。

//自底向上归并排序
public ListNode sortList(ListNode head) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    int n = 0;
    while (head!=null){
        head = head.next;
        n++;
    }

    for (int step = 1;step < n; step<<=1){
        ListNode pre = dummy;
        ListNode cur = dummy.next;
        while (cur!=null){
            ListNode left = cur;
            ListNode right = split(left, step);
            cur = split(right, step);
            pre = merge(left, right, pre);
        }
    }
    return dummy.next;
}


//将链表 head 切掉前 step 个节点，并返回后半部分的链表头。(从head往后走n-1步，然后断链)
private ListNode split(ListNode head, int step){
    if (head==null) return null;
    for (int i = 1;head.next != null && i < step;i++){
        head = head.next;
    }
    ListNode right = head.next;
    head.next = null;
    return right;
}

//合并left和right链表，并返回合并后的最后一个节点
private ListNode merge(ListNode left, ListNode right, ListNode prev){
    ListNode cur = prev;
    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;
    while (cur.next!=null)
        cur = cur.next;
    return cur;
}

归并排序（递归）

重点也在于分割链表，使用快慢指针分割。注释很详细

public ListNode sortList(ListNode head) {
    if (head==null || head.next == null)    return head;

    //快慢指针分割链表，奇数个节点找到中点，偶数个节点找到中心左边的节点。
    //初始化slow，fast即第一次走完的结果。
    ListNode slow = head, fast = head.next;
    while (fast!=null && fast.next!=null){
        slow = slow.next;
        fast = fast.next.next;
    }
    //slow指针的next就是分割出来right链表的头结点
    ListNode fastHead = slow.next;
    //然后断链
    slow.next = null;
    //递归分割
    ListNode left = sortList(head);
    ListNode right = sortList(fastHead);
    //当递归到链表中只有1个或0个节点时归并
    return merge(left, right);
}

private ListNode merge(ListNode l1, ListNode l2){
    ListNode dummyHead = new ListNode(-1);
    ListNode cur = dummyHead;
    while (l1!=null && l2!=null){
        if (l1.val<=l2.val){
            cur.next = l1;
            l1 = l1.next;
        } else {
            cur.next = l2;
            l2 = l2.next;
        }
        cur = cur.next;
    }
    cur.next = l1==null ? l2 : l1;
    return dummyHead.next;
}