LeetCode 148. Sort List 题解

LeetCode 148. Sort List 题解

题目描述

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

示例 1：

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

示例 2：

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

示例 3：

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

解题思路

方法：归并排序

思路：

• 使用归并排序对链表进行排序
• 找到链表的中点，将链表分成两部分
• 递归地对两部分进行排序
• 将排序后的两部分合并

复杂度分析：

• 时间复杂度：O(n log n)，其中 n 是链表的长度。归并排序的时间复杂度是 O(n log n)。
• 空间复杂度：O(log n)，递归调用栈的深度。

代码实现

方法：归并排序

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 基本情况
        if not head or not head.next:
            return head
        
        # 找到链表的中点
        slow = head
        fast = head.next
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        
        # 分割链表
        mid = slow.next
        slow.next = None
        
        # 递归地对两部分进行排序
        left = self.sortList(head)
        right = self.sortList(mid)
        
        # 合并排序后的两部分
        return self.merge(left, right)
    
    def merge(self, left: Optional[ListNode], right: Optional[ListNode]) -> Optional[ListNode]:
        # 创建虚拟头节点
        dummy = ListNode(0)
        current = dummy
        
        # 合并两个链表
        while left and right:
            if left.val < right.val:
                current.next = left
                left = left.next
            else:
                current.next = right
                right = right.next
            current = current.next
        
        # 处理剩余的节点
        if left:
            current.next = left
        if right:
            current.next = right
        
        return dummy.next

测试用例

测试用例 1：

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

测试用例 2：

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

测试用例 3：

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

总结

本题是归并排序的经典应用问题，主要考察对归并排序思想的理解和使用。通过使用归并排序，我们可以高效地对链表进行排序。

归并排序的核心思想是：找到链表的中点，将链表分成两部分，递归地对两部分进行排序，然后将排序后的两部分合并。

这种方法不仅适用于排序链表问题，还可以应用于许多其他需要排序的问题。掌握归并排序的思想，对于解决这类问题非常重要。