Merge Two Sorted Lists

Merge Two Sorted Lists - Problem

You are given the heads of two sorted linked lists list1 and list2.

Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists.

Return the head of the merged linked list.

Input & Output

Example 1 — Basic Merge

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

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

💡 Note: Merge by comparison: 1≤1 (choose list1), 2<3 (choose list1), 3<4 (choose list2), 4≤4 (choose list1), then 4 from list2

Example 2 — One Empty List

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

› Output: [0]

💡 Note: When one list is empty, return the other list directly

Example 3 — Both Empty

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

› Output: []

💡 Note: When both lists are empty, return empty list

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.

Visualization

Tap to expand

Asked in

a Amazon 87 M Microsoft 45 🍎 Apple 32 G Google 28

The key insight is that since both lists are already sorted, we can merge them in one pass by comparing current nodes. The two-pointer approach is optimal with Time: O(m + n), Space: O(1).

Common Approaches

✓ Brute Force - Collect and Sort

⏱️ Time: O(n log n) Space: O(n)

Extract all values from both linked lists into an array, sort the array, then create a new linked list from the sorted values.

Two Pointers Merge

⏱️ Time: O(m + n) Space: O(1)

Use two pointers to traverse both lists simultaneously, always choosing the smaller node to add to the result. This leverages the fact that both input lists are already sorted.

Brute Force - Collect and Sort — Algorithm Steps

Step 1: Traverse both lists and collect all values
Step 2: Sort the collected values
Step 3: Create new linked list from sorted values

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Collect all values from both lists into array

Sort Array

Sort the collected values

Build New List

Create new linked list from sorted array

Code -

solution.c — C

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

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

struct ListNode* solution(struct ListNode* list1, struct ListNode* list2) {
    int values[20000];
    int count = 0;
    
    struct ListNode* current = list1;
    while (current) {
        values[count++] = current->val;
        current = current->next;
    }
    
    current = list2;
    while (current) {
        values[count++] = current->val;
        current = current->next;
    }
    
    qsort(values, count, sizeof(int), compare);
    
    if (count == 0) return NULL;
    
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = values[0];
    head->next = NULL;
    current = head;
    
    for (int i = 1; i < count; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = values[i];
        current->next = NULL;
    }
    
    return head;
}

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = arr[i];
        current->next = NULL;
    }
    return head;
}

void printList(struct ListNode* head) {
    printf("[");
    int first = 1;
    while (head) {
        if (!first) printf(",");
        printf("%d", head->val);
        first = 0;
        head = head->next;
    }
    printf("]\n");
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int arr1[100], size1 = 0;
    if (strcmp(line, "[]") != 0) {
        char* token = strtok(line + 1, ",]");
        while (token) {
            arr1[size1++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int arr2[100], size2 = 0;
    if (strcmp(line, "[]") != 0) {
        char* token = strtok(line + 1, ",]");
        while (token) {
            arr2[size2++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    struct ListNode* list1 = arrayToList(arr1, size1);
    struct ListNode* list2 = arrayToList(arr2, size2);
    
    struct ListNode* result = solution(list1, list2);
    printList(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to collect values + O(n log n) to sort + O(n) to build list

✓ Linear Growth

Space Complexity

O(n)

Array to store all values from both lists

✓ Linear Space

180.3K Views

Very High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Collect and Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler