304 North Cardinal St.
Dorchester Center, MA 02124

# Merge k Sorted Lists LeetCode Solution

## Problem – Merge k Sorted Lists

You are given an array of `k` linked-lists `lists`, each linked-list is sorted in ascending order.

Example 1:

``````Input: lists = [[1,4,5],[1,3,4],[2,6]]
Output: [1,1,2,3,4,4,5,6]
[
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 <= 104`
• `0 <= lists[i].length <= 500`
• `-104 <= lists[i][j] <= 104`
• `lists[i]` is sorted in ascending order.
• The sum of `lists[i].length` will not exceed `104`.

### Merge k Sorted Lists LeetCode Solution in Java

``````public class Solution {
public ListNode mergeKLists(List<ListNode> lists) {
if (lists==null||lists.size()==0) return null;

PriorityQueue<ListNode> queue= new PriorityQueue<ListNode>(lists.size(),new Comparator<ListNode>(){
@Override
public int compare(ListNode o1,ListNode o2){
if (o1.val<o2.val)
return -1;
else if (o1.val==o2.val)
return 0;
else
return 1;
}
});

ListNode dummy = new ListNode(0);
ListNode tail=dummy;

for (ListNode node:lists)
if (node!=null)

while (!queue.isEmpty()){
tail.next=queue.poll();
tail=tail.next;

if (tail.next!=null)
}
return dummy.next;
}
}
``````

### Merge k Sorted Lists LeetCode Solution in C++

``````ListNode *mergeKLists(vector<ListNode *> &lists) {
if(lists.empty()){
return nullptr;
}
while(lists.size() > 1){
lists.push_back(mergeTwoLists(lists[0], lists[1]));
lists.erase(lists.begin());
lists.erase(lists.begin());
}
return lists.front();
}
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
if(l1 == nullptr){
return l2;
}
if(l2 == nullptr){
return l1;
}
if(l1->val <= l2->val){
l1->next = mergeTwoLists(l1->next, l2);
return l1;
}
else{
l2->next = mergeTwoLists(l1, l2->next);
return l2;
}
}
``````

### Merge k Sorted Lists LeetCode Solution in Python

``````class Solution(object):
def mergeKLists(self, lists):
if not lists:
return None
if len(lists) == 1:
return lists[0]
mid = len(lists) // 2
l, r = self.mergeKLists(lists[:mid]), self.mergeKLists(lists[mid:])
return self.merge(l, r)

def merge(self, l, r):
dummy = p = ListNode()
while l and r:
if l.val < r.val:
p.next = l
l = l.next
else:
p.next = r
r = r.next
p = p.next
p.next = l or r
return dummy.next

def merge1(self, l, r):
if not l or not r:
return l or r
if l.val< r.val:
l.next = self.merge(l.next, r)
return l
r.next = self.merge(l, r.next)
return r
``````
##### Merge k Sorted Lists LeetCode Solution Review:

In our experience, we suggest you solve this Merge k Sorted Lists LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Merge k Sorted Lists LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Merge k Sorted Lists LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions