排序实现题目：排序链表

题目

标题和出处

标题：排序链表

出处：148. 排序链表

难度

6 级

题目描述

要求

给定链表的头结点 $\text{head}$，请将其按升序排序，并返回排序后的链表。

示例

示例 1：

输入：$\text{head = [4,2,1,3]}$
输出：$\text{[1,2,3,4]}$

示例 2：

输入：$\text{head = [-1,5,3,4,0]}$
输出：$\text{[-1,0,3,4,5]}$

示例 3：

输入：$\text{head = []}$
输出：$\text{[]}$

数据范围

• 链表中结点的数目范围是 $\text{[0, 5}\times {\text{10}}^{\text{4}}\text{]}$
• ${\text{-10}}^{\text{5}}\le \text{Node.val}\le {\text{10}}^{\text{5}}$

进阶

你可以在 $\text{O(n log n)}$ 时间复杂度和 $\text{O(1)}$（常数级）空间复杂度下，对链表进行排序吗？

前言

由于链表的结构不同于数组，因此适用于链表的排序种类较少。这道题中，链表的长度最大为 $5\times 10^4$，因此时间复杂度是 $O(n^2)$ 的排序算法不适合这道题，需要使用时间复杂度更低的排序算法。根据链表的性质，可以使用归并排序对链表排序。归并排序的时间复杂度是 $O(n\log n)$，自顶向下实现和自底向上实现的空间复杂度分别是 $O(\log n)$ 和 $O(1)$。

解法一

思路和算法

归并排序使用分治的思想。对链表归并排序，首先将链表拆分成多个不相交的子链表，对每个子链表排序，然后将排序后的子链表合并，合并过程中确保合并后的子链表仍然有序。合并结束之后，整个链表排序结束。

使用自顶向下的方式实现时，首先判断链表的长度是否需要拆分。如果链表的长度是 $0$（即链表为空）或 $1$，则不需要拆分，此时链表已经有序，因此直接返回链表。

当链表的长度大于 $1$ 时，需要将链表拆分成两个子链表，对两个子链表分别排序，然后将排序后的两个子链表合并。具体做法如下。

1. 找到链表的中间结点。使用快慢指针法，做法和「链表的中间结点」相似，但是有所区别，初始时将快指针置于慢指针前面一个位置，当快指针到达末尾时，慢指针到达中间结点，当链表长度是偶数时慢指针将到达左边的中间结点。
2. 将中间结点的后一个结点作为第二个子链表的头结点，将中间结点和后一个结点之间的连接断开，此时链表拆分成两个子链表且两个子链表的长度之差不超过 $1$。
3. 对两个子链表调用递归完成排序。
4. 将排序后的两个子链表合并，使用「合并两个有序链表」的做法。

代码

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 head2 = slow.next;
        slow.next = null;
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(head2);
        return mergeTwoLists(l1, l2);
    }

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                temp.next = l1;
                l1 = l1.next;
            } else {
                temp.next = l2;
                l2 = l2.next;
            }
            temp = temp.next;
        }
        if (l1 != null) {
            temp.next = l1;
        } else {
            temp.next = l2;
        }
        return dummyHead.next;
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是链表的长度。

• 空间复杂度：$O(\log n)$，其中 $n$ 是链表的长度。空间复杂度主要取决于递归调用的栈空间，递归调用栈的深度是 $O(\log n)$。

解法二

思路和算法

使用自底向上的方式实现，可以省略递归调用的栈空间，将空间复杂度降低到 $O(1)$。

首先遍历链表得到链表的长度，然后从长度是 $1$ 的子链表开始合并。将每两个相邻的子链表合并，使用「合并两个有序链表」的做法。然后将子链表的长度乘以 $2$，重复上述合并操作，直到所有的子链表合并成一个链表时，排序结束。

代码

class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        int length = 0;
        ListNode node = head;
        while (node != null) {
            length++;
            node = node.next;
        }
        ListNode dummyHead = new ListNode(0, head);
        for (int halfLength = 1; halfLength < length; halfLength *= 2) {
            ListNode prev = dummyHead, curr = dummyHead.next;
            while (curr != null) {
                ListNode l1 = curr;
                for (int i = 1; i < halfLength && curr.next != null; i++) {
                    curr = curr.next;
                }
                ListNode l2 = curr.next;
                curr.next = null;
                curr = l2;
                for (int i = 1; i < halfLength && curr != null && curr.next != null; i++) {
                    curr = curr.next;
                }
                ListNode next = null;
                if (curr != null) {
                    next = curr.next;
                    curr.next = null;
                }
                ListNode merged = mergeTwoLists(l1, l2);
                prev.next = merged;
                while (prev.next != null) {
                    prev = prev.next;
                }
                curr = next;
            }
        }
        return dummyHead.next;
    }

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                temp.next = l1;
                l1 = l1.next;
            } else {
                temp.next = l2;
                l2 = l2.next;
            }
            temp = temp.next;
        }
        if (l1 != null) {
            temp.next = l1;
        } else {
            temp.next = l2;
        }
        return dummyHead.next;
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是链表的长度。

• 空间复杂度：$O(1)$。