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: []
The given problem requires merging k sorted linked lists into a single sorted linked list. One way to approach this problem is to repeatedly merge pairs of linked lists until there is only one linked list remaining.
The mergeKLists function takes a list of linked lists as input.
It repeatedly merges pairs of linked lists until there is only one linked list remaining in the list.
The mergelists function is a helper function that merges two sorted linked lists. It iterates through the nodes of both lists, comparing the values, and building a new sorted list.
The merged lists are stored in the mergelist variable, and the process is repeated until there is only one list left.
The final merged list is returned.
The time complexity is O(n log(k)), where n is the total number of nodes across all lists, and k is the number of lists.
The space complexity is O(1) as we use only a constant amount of extra space.
# 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 or len(lists) == 0:
return None
while len(lists) > 1:
mergelist = []
for i in range(0 , len(lists) , 2):
l1 = lists[i]
l2 = lists[i + 1] if i + 1 < len(lists) else None
mergelist.append(self.mergelists(l1 , l2))
lists = mergelist
return lists[0]
def mergelists(self, l1, l2):
current = dummy = ListNode()
while l1 and l2:
if l1.val < l2.val:
current.next = l1
l1 = l1.next
else:
current.next = l2
l2 = l2.next
current = current.next
if l1 or l2:
current.next = l1 if l1 else l2
return dummy.next