23. Merge k Sorted Lists
Hard
6875349Add to ListShare
You are given an array of k
linked-lists lists
, each linked-list is sorted in ascending order.
Merge all the linked-lists into one sorted linked-list and return it.
Example 1:
Input: lists = [[1,4,5],[1,3,4],[2,6]] Output: [1,1,2,3,4,4,5,6] Explanation: The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted list: 1->1->2->3->4->4->5->6
Example 2:
Input: lists = [] Output: []
Example 3:
Input: lists = [[]] Output: []
Constraints:
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i]
is sorted in ascending order.- The sum of
lists[i].length
won't exceed10^4
.
我的思路 :参考:21. Merge Two Sorted Lists,将实现抽成方法循环调用,直到列表变成一个。时间复杂度: 最坏约等于 O(kN),其中N是所有节点数量
# 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[ListNode]) -> ListNode:
def mergeTwoLists(l1: ListNode, l2: ListNode) -> ListNode:
if l1 is None:
return l2
if l2 is None:
return l1
head_node = cur_node = None
while l1 and l2:
node = None
if l1.val < l2.val:
node = l1
l1 = l1.next
else:
node = l2
l2 = l2.next
if head_node is None:
head_node = cur_node = node
else:
cur_node.next = node
cur_node = node
while l1:
cur_node.next = l1
cur_node = l1
l1 = l1.next
while l2:
cur_node.next = l2
cur_node = l2
l2 = l2.next
return head_node
if lists is None or len(lists) <= 0:
return None
node = mergeTwoLists(lists[0], None)
i = 1
while i < len(lists):
node = mergeTwoLists(node, lists[i])
i += 1
return node
参考答案 https://leetcode.com/problems/merge-k-sorted-lists/solution/
解法1:暴力排序
时间:O(NlogN) N is the total number of nodes.
空间:O(1)
# 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):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
self.nodes = []
head = point = ListNode(0)
for l in lists:
while l:
self.nodes.append(l.val)
l = l.next
for x in sorted(self.nodes):
point.next = ListNode(x)
point = point.next
return head.next
解法3:优先队列
优先队列始终保持k个数,即k个列表当前的最小的数,即O(logk)
时间:O(Nlogk) k is the number of linked lists.
from Queue import PriorityQueue
class Solution(object):
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
head = point = ListNode(0)
q = PriorityQueue()
for l in lists:
if l:
q.put((l.val, l))
while not q.empty():
val, node = q.get()
point.next = ListNode(val)
point = point.next
node = node.next
if node:
q.put((node.val, node))
return head.next
解法4:和我的一样
解法5:优化了解法4,不从头开始一个个合并,而是采用2个一组合并,合并次数的时间复杂度直接降到O(logk)
即时间复杂度:O(Nlogk),其中N是每次合并时间复杂度是当前2个列表的节点数和