当前位置：首页 > article >正文

【hot100】刷题记录(52)-合并K个升序链表

article 2025/3/31 8:35:23

题目描述：

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按升序排列
lists[i].length 的总和不超过 10^4

我的作答：

就是全部转换为数组，数组排序后再新建一个链表，听着很繁琐，空间复杂度也高但是很简单。。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        if not lists: return None
        nums = []
        for i in range(len(lists)): #把链表元素全部提取出来变成数组
            cur = lists[i]
            while cur:
                nums.append(cur.val)
                cur = cur.next
        nums.sort() #给数组排序
        if not nums: return None
        head = ListNode(nums[0])
        if len(nums)==1: return head
        node = ListNode()
        head.next = node
        for i in range(1, len(nums)): #新建一个链表，把数组元素挨个转换过去
            node.val = nums[i]
            if i<len(nums)-1:
                next_node = ListNode()
                node.next = next_node
                node = next_node
        return head

参考：

使用堆的方法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        h = [(lists[i].val, i, lists[i]) for i in range(len(lists)) if lists[i]]
        heapify(h)
        dummy = ListNode(-1, None)
        cur = dummy
        while h:
            _, i, node = heappop(h)
            cur.next = node
            if node.next:
                heappush(h, (node.next.val, i, node.next))
            cur = cur.next
        return dummy.next