Merge Two Sorted Lists - Practice Coding Problems

Merge Two Sorted Lists - Problem

Given the heads of two sorted linked lists list1 and list2, merge them into a single sorted linked list.

The merged list should be constructed by splicing together the nodes from the input lists - don't create new nodes, just rearrange the existing ones. Return the head of the newly merged linked list.

Example:
Input: list1 = [1,2,4], list2 = [1,3,4]
Output: [1,1,2,3,4,4]

This is a classic linked list problem that tests your understanding of pointer manipulation and merging algorithms. It's the foundation for more complex problems like merging k sorted lists.

Input & Output

example_1.py — Basic Merge

$ Input: list1 = [1,2,4], list2 = [1,3,4]

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

💡 Note: Both lists start with 1, so we take from list1 first. Then we compare 2 vs 1 (from list2), take 1. Continue this process: 2 vs 3 (take 2), 4 vs 3 (take 3), 4 vs 4 (take from list1), then append remaining 4 from list2.

example_2.py — Empty List

$ Input: list1 = [], list2 = [0]

› Output: [0]

💡 Note: When one list is empty, we simply return the other list. No comparison needed.

example_3.py — Both Empty

$ Input: list1 = [], list2 = []

› Output: []

💡 Note: When both lists are empty, the result is also an empty list.

Visualization

Tap to expand

Understanding the Visualization

Setup

Start with two sorted lines and an empty result line

Compare

Look at the first person in each line

Choose

Move the shorter person to the result line

Repeat

Continue until one line is empty

Finish

Move all remaining people from the non-empty line

Key Takeaway

🎯 Key Insight: Since both input lists are already sorted, we only need to compare the first elements and choose the smaller one at each step. This gives us O(n+m) time with O(1) space complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Visit each node exactly once where n and m are lengths of the lists

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for pointers

✓ Linear Space

Constraints

The number of nodes in both lists is in the range [0, 50]
-100 ≤ Node.val ≤ 100
Both list1 and list2 are sorted in non-decreasing order

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses a two-pointer approach with O(n + m) time complexity and O(1) space complexity. By comparing the current nodes of both lists and always choosing the smaller value, we can merge the lists in a single pass while maintaining the sorted order. A dummy head node simplifies the logic by eliminating edge case handling.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to compare and merge nodes directly
Brute Force (Convert to Array)	O(n + m)	O(n + m)	Convert both linked lists to arrays, merge arrays, then rebuild linked list

Two Pointers (Optimal) — Algorithm Steps

Create a dummy head node to simplify edge cases
Use two pointers, one for each input list
Compare current nodes and attach smaller one to result
Advance the pointer of the list from which we took the node
When one list is exhausted, append the remaining nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set up dummy head and two pointers

Compare Values

Compare current nodes from both lists

Attach Smaller

Link smaller node to result and advance pointer

Append Remainder

Attach remaining nodes when one list is exhausted

Code -

solution.c — C

// Definition for singly-linked list
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    // Create dummy head to simplify logic
    struct ListNode dummy = {0, NULL};
    struct ListNode* current = &dummy;
    
    // Two pointers for the input lists
    struct ListNode* ptr1 = list1;
    struct ListNode* ptr2 = list2;
    
    // Compare and merge while both lists have nodes
    while (ptr1 && ptr2) {
        if (ptr1->val <= ptr2->val) {
            current->next = ptr1;
            ptr1 = ptr1->next;
        } else {
            current->next = ptr2;
            ptr2 = ptr2->next;
        }
        current = current->next;
    }
    
    // Append remaining nodes from non-empty list
    current->next = ptr1 ? ptr1 : ptr2;
    
    // Return the actual head (skip dummy)
    return dummy.next;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Visit each node exactly once where n and m are lengths of the lists

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for pointers

✓ Linear Space

Constraints

The number of nodes in both lists is in the range [0, 50]
-100 ≤ Node.val ≤ 100
Both list1 and list2 are sorted in non-decreasing order

142.4K Views

Very High Frequency

~15 min Avg. Time

2.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler