📝 题目描述

题目链接：排序链表

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

示例：

示例 1：

1
2
输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]

示例 2：

1
2
输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

1
2
输入：head = []
输出：[]

提示：

  • 链表中节点的数目在范围 [0, 5 * 10^4] 内
  • -10^5 <= Node.val <= 10^5

💡 解题思路

方法一：使用multimap

map的key是天然有序的，不过考虑到数字有可能重复，我们需要使用multimap。

方法二：自顶向下归并排序✅️

对链表自顶向下归并排序的过程如下。

  1. 找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2 步，慢指针每次移动 1 步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点；
  2. 对两个子链表分别排序（左闭右开区间）；
  3. 将两个排序后的子链表合并，得到完整的排序后的链表。可以使用“合并两个有序链表”的做法，将两个有序的子链表进行合并。

上述过程可以通过递归实现。递归的终止条件是链表的节点个数小于或等于 1，即当链表为空或者链表只包含 1 个节点时，不需要对链表进行拆分和排序。

★方法三：自底向上归并排序

使用自底向上的方法实现归并排序，则可以达到 O(1)O(1) 的空间复杂度。

首先求得链表的长度 length，然后将链表拆分成子链表进行合并。

具体做法如下。

  1. 用 subLengthsubLength 表示每次需要排序的子链表的长度，初始时 subLength=1subLength=1。
  2. 每次将链表拆分成若干个长度为 subLengthsubLength 的子链表（最后一个子链表的长度可以小于 subLengthsubLength），按照每两个子链表一组进行合并，合并后即可得到若干个长度为 subLength×2subLength×2 的有序子链表（最后一个子链表的长度可以小于 subLength×2subLength×2）。合并两个子链表仍然使用“合并两个有序链表”的做法。
  3. 将 subLengthsubLength 的值加倍，重复第 2 步，对更长的有序子链表进行合并操作，直到有序子链表的长度大于或等于 lengthlength，整个链表排序完毕。

如何保证每次合并之后得到的子链表都是有序的呢？可以通过数学归纳法证明。

  1. 初始时 subLength=1subLength=1，每个长度为 1 的子链表都是有序的。
  2. 如果每个长度为 subLengthsubLength 的子链表已经有序，合并两个长度为 subLengthsubLength 的有序子链表，得到长度为 subLength×2subLength×2 的子链表，一定也是有序的。
  3. 当最后一个子链表的长度小于 subLengthsubLength 时，该子链表也是有序的，合并两个有序子链表之后得到的子链表一定也是有序的。

因此可以保证最后得到的链表是有序的。

🔧 代码实现

1、使用multimap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
 * 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) return nullptr;
        multimap<int, ListNode*> mp;
        ListNode* ptr = head, *ans = nullptr;
        // 插入节点
        while (ptr != nullptr) {
            mp.insert({ptr->val, ptr});
            ptr = ptr -> next;
        }

        ptr = nullptr;
        // 遍历，重新连接
        for (auto& t : mp) {
            if (!ptr) {
                ptr = t.second;
                ans = t.second;
            } else {
                ptr -> next = t.second;
                ptr = t.second;
            }
        }

        // 断开最后一个的循环
        if (ptr != nullptr) {
            ptr -> next = nullptr;
        }

        return ans;
    }
};

2、自顶向下归并排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/**
 * 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) {
        return sortList(head, nullptr);
    }
    // 区间：[head, tail)
    ListNode* sortList(ListNode* head, ListNode* tail) {
        // 空链表，直接返回
        if (head == nullptr) {
            return head;
        }
        // 很重要，割断最后一个节点
        if (head -> next == tail) {
            head -> next = nullptr;
            return head;
        }
        // 快慢指针寻找中点
        ListNode* fast = head, *slow = head;
        while (fast != tail && fast -> next != tail) {
            fast = fast -> next -> next;
            slow = slow -> next;
        }
        return merge(sortList(head, slow), sortList(slow, tail));
    }
    ListNode* merge(ListNode* ptr1, ListNode* ptr2) {
        ListNode* dummy = new ListNode(-1);
        ListNode* prev = dummy;
        while (ptr1 != nullptr && ptr2 != nullptr) {
            if (ptr1 ->  val < ptr2 -> val) {
                prev -> next = ptr1;
                ptr1 = ptr1 -> next; 
            } else {
                prev -> next = ptr2;
                ptr2 = ptr2 -> next;
            }
            prev = prev -> next;
        }

        prev -> next = ptr1 == nullptr ? ptr2 : ptr1;

        ListNode* ans = dummy -> next;
        delete dummy;
        return ans;
    }
};

3、自底向上归并排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if (head == nullptr) {
            return head;
        }
        int length = 0;
        ListNode* node = head;
        while (node != nullptr) {
            length++;
            node = node->next;
        }
        ListNode* dummyHead = new ListNode(0, head);
        for (int subLength = 1; subLength < length; subLength <<= 1) {
            ListNode* prev = dummyHead, *curr = dummyHead->next;
            while (curr != nullptr) {
                ListNode* head1 = curr;
                for (int i = 1; i < subLength && curr->next != nullptr; i++) {
                    curr = curr->next;
                }
                ListNode* head2 = curr->next;
                curr->next = nullptr;
                curr = head2;
                for (int i = 1; i < subLength && curr != nullptr && curr->next != nullptr; i++) {
                    curr = curr->next;
                }
                ListNode* next = nullptr;
                if (curr != nullptr) {
                    next = curr->next;
                    curr->next = nullptr;
                }
                ListNode* merged = merge(head1, head2);
                prev->next = merged;
                while (prev->next != nullptr) {
                    prev = prev->next;
                }
                curr = next;
            }
        }
        return dummyHead->next;
    }

    ListNode* merge(ListNode* head1, ListNode* head2) {
        ListNode* dummyHead = new ListNode(0);
        ListNode* temp = dummyHead, *temp1 = head1, *temp2 = head2;
        while (temp1 != nullptr && temp2 != nullptr) {
            if (temp1->val <= temp2->val) {
                temp->next = temp1;
                temp1 = temp1->next;
            } else {
                temp->next = temp2;
                temp2 = temp2->next;
            }
            temp = temp->next;
        }
        if (temp1 != nullptr) {
            temp->next = temp1;
        } else if (temp2 != nullptr) {
            temp->next = temp2;
        }
        return dummyHead->next;
    }
};

📊 复杂度分析

1、使用multimap

  • 时间复杂度：O(nlogn)O(nlogn)，map 底层是红黑树（自带排序功能）。
  • 空间复杂度：O(n)O(n)。

2、自顶向下归并排序

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

3、自底向上归并排序

  • 时间复杂度：O(nlogn)O(nlogn)，其中 n 是链表的长度。
  • 空间复杂度：O(1)O(1)。

🎯 总结

  • 核心思想：掌握归并排序的思想。