Physical Address

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.

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:
merging them into one sorted list:

Example 2:

Input: lists = []
Output: []

Example 3:

Input: lists = [[]]
Output: []


  • 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>(){
            public int compare(ListNode o1,ListNode o2){
                if (o1.val<o2.val)
                    return -1;
                else if (o1.val==o2.val)
                    return 0;
                    return 1;
        ListNode dummy = new ListNode(0);
        ListNode tail=dummy;
        for (ListNode node:lists)
            if (node!=null)
        while (!queue.isEmpty()){
            if (!=null)

Merge k Sorted Lists LeetCode Solution in C++

ListNode *mergeKLists(vector<ListNode *> &lists) {
        return nullptr;
    while(lists.size() > 1){
        lists.push_back(mergeTwoLists(lists[0], lists[1]));
    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;
        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:
       = l
                l =
       = r
                r =
            p = = l or r
    def merge1(self, l, r):
        if not l or not r:
            return l or r
        if l.val< r.val:
   = self.merge(, r)
            return l = self.merge(l,
        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


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

Leave a Reply

Your email address will not be published. Required fields are marked *