Merge k Sorted Lists - Practice Coding Problems

Merge k Sorted Lists - Problem

Merge k Sorted Lists is a classic divide-and-conquer problem that challenges you to efficiently combine multiple sorted linked lists into a single sorted result.

You are given an array of k linked lists, where each list is already sorted in ascending order. Your task is to merge all these lists into one unified sorted linked list and return the head of this merged list.

🎯 Goal: Combine k sorted linked lists efficiently
📥 Input: Array of k sorted linked list heads
📤 Output: Head of the merged sorted linked list

This problem tests your understanding of merge algorithms, priority queues, and divide-and-conquer strategies. It's frequently asked in technical interviews at top tech companies!

Input & Output

example_1.py — Basic case with three lists

$ Input: lists = [[1,4,5],[1,3,4],[2,6]]

› Output: [1,1,2,3,4,4,5,6]

💡 Note: The linked-lists are: [1→4→5], [1→3→4], [2→6]. Merging them in sorted order gives us 1→1→2→3→4→4→5→6.

example_2.py — Empty lists array

$ Input: lists = []

› Output: []

💡 Note: No linked lists to merge, so return null/empty.

example_3.py — Array with one empty list

$ Input: lists = [[]]

› Output: []

💡 Note: The only list is empty, so the merged result is also empty.

Time & Space Complexity

Time Complexity

⏱️

O(N log k)

Where N is total nodes and k is number of lists. We merge lists log k times, and each merge processes all N nodes.

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space for merge operations. The recursion uses O(log k) stack space, but iterative version uses O(1).

✓ Linear Space

Constraints

k == lists.length
0 ≤ k ≤ 10⁴
0 ≤ lists[i].length ≤ 500
-10⁴ ≤ lists[i][j] ≤ 10⁴
lists[i] is sorted in ascending order
The sum of lists[i].length will not exceed 10⁴

Asked in

The optimal solution uses divide and conquer approach with O(N log k) time complexity. By pairing up lists and merging them two at a time (like a tournament bracket), we reduce the problem size by half at each level. This is more efficient than the heap approach and uses only O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Divide and Conquer (Optimal)	O(N log k)	O(1)	Pair up lists and merge them two at a time, reducing the problem size by half at each level
Priority Queue (Min-Heap)	O(N log k)	O(k)	Use a min-heap to efficiently find the smallest element among k list heads
Brute Force (Collect & Sort)	O(N log N)	O(N)	Collect all nodes into an array, sort by value, then reconstruct the linked list

Divide and Conquer (Optimal) — Algorithm Steps

Start with the array of k linked lists
Pair up adjacent lists and merge each pair using two-pointer technique
Replace the original k lists with k/2 merged lists
Repeat until only one list remains
Return the final merged list

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Lists

Start with k sorted lists

Round 1 Pairing

Pair adjacent lists and merge each pair

Round 2 Pairing

Merge results from previous round

Final Result

Continue until one list remains

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode dummy;
    struct ListNode* current = &dummy;
    
    while (l1 && l2) {
        if (l1->val <= l2->val) {
            current->next = l1;
            l1 = l1->next;
        } else {
            current->next = l2;
            l2 = l2->next;
        }
        current = current->next;
    }
    
    current->next = l1 ? l1 : l2;
    return dummy.next;
}

struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {
    if (listsSize == 0) {
        return NULL;
    }
    if (listsSize == 1) {
        return lists[0];
    }
    
    while (listsSize > 1) {
        int mergedSize = 0;
        
        for (int i = 0; i < listsSize; i += 2) {
            struct ListNode* l1 = lists[i];
            struct ListNode* l2 = (i + 1 < listsSize) ? lists[i + 1] : NULL;
            lists[mergedSize++] = mergeTwoLists(l1, l2);
        }
        
        listsSize = mergedSize;
    }
    
    return lists[0];
}

Time & Space Complexity

Time Complexity

⏱️

O(N log k)

Where N is total nodes and k is number of lists. We merge lists log k times, and each merge processes all N nodes.

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space for merge operations. The recursion uses O(log k) stack space, but iterative version uses O(1).

✓ Linear Space

Constraints

k == lists.length
0 ≤ k ≤ 10⁴
0 ≤ lists[i].length ≤ 500
-10⁴ ≤ lists[i][j] ≤ 10⁴
lists[i] is sorted in ascending order
The sum of lists[i].length will not exceed 10⁴

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Divide and Conquer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler