Merge In Between Linked Lists

Merge In Between Linked Lists - Problem

Linked List Medium

You are given two linked lists: list1 and list2 of sizes n and m respectively.

Remove list1's nodes from the ath node to the bth node, and put list2 in their place.

Build the result list and return its head.

Input & Output

Example 1 — Basic Replacement

$ Input: list1 = [0,1,2,3,4], a = 1, b = 3, list2 = [1000000,1000001,1000002]

› Output: [0,1000000,1000001,1000002,4]

💡 Note: Remove nodes from index 1 to 3 (values 1,2,3) and replace with list2. Keep node 0 and node 4, insert list2 in between.

Example 2 — Single Node Replacement

$ Input: list1 = [0,1,2,3,4], a = 3, b = 3, list2 = [1000000,1000001]

› Output: [0,1,2,1000000,1000001,4]

💡 Note: Remove only the node at index 3 (value 3) and replace with list2. Result keeps 0,1,2, inserts list2, then keeps 4.

Example 3 — Edge Case at End

$ Input: list1 = [0,1,2], a = 1, b = 2, list2 = [5,6,7]

› Output: [0,5,6,7]

💡 Note: Remove nodes 1 and 2 from the end, replace with list2. Only node 0 remains from original list.

Constraints

3 ≤ list1.length ≤ 10⁴
1 ≤ a ≤ b < list1.length - 1
1 ≤ list2.length ≤ 10⁴
1 ≤ list1[i], list2[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

M Microsoft 35 a Amazon 28 G Google 22

The key insight is to use direct pointer manipulation to splice list2 into list1 by identifying connection points and reconnecting pointers. The optimal approach uses O(1) space by manipulating pointers directly without extra arrays. Time: O(n+m), Space: O(1).

Common Approaches

✓ Brute Force - Array Conversion

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

Convert both linked lists to arrays, perform the replacement in the array, then rebuild the linked list from the modified array. This approach is straightforward but uses extra space.

Direct Pointer Manipulation

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

Find the node before position a, traverse to position b, then reconnect pointers to insert list2 and remove the unwanted segment. This approach modifies the linked list in-place.

Brute Force - Array Conversion — Algorithm Steps

Step 1: Convert list1 to array
Step 2: Convert list2 to array
Step 3: Replace elements from index a to b with list2
Step 4: Rebuild linked list from array

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Arrays

Transform linked lists into arrays

Array Replacement

Replace array segment with list2 elements

Rebuild List

Convert final array back to linked list

Code -

solution.c — C

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

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

struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

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

int listToArray(struct ListNode* head, int* arr) {
    int size = 0;
    struct ListNode* current = head;
    while (current) {
        arr[size++] = current->val;
        current = current->next;
    }
    return size;
}

struct ListNode* solution(struct ListNode* list1, int a, int b, struct ListNode* list2) {
    int arr1[1000], arr2[1000], result[2000];
    int size1 = listToArray(list1, arr1);
    int size2 = listToArray(list2, arr2);
    
    int resultSize = 0;
    for (int i = 0; i < a; i++) result[resultSize++] = arr1[i];
    for (int i = 0; i < size2; i++) result[resultSize++] = arr2[i];
    for (int i = b + 1; i < size1; i++) result[resultSize++] = arr1[i];
    
    return arrayToList(result, resultSize);
}

int main() {
    char line[10000];
    int list1Vals[1000], list2Vals[1000];
    int size1 = 0, size2 = 0;
    
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[,]");
    while (token) {
        if (strlen(token) > 0 && token[0] != '\n') {
            list1Vals[size1++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int a, b;
    scanf("%d", &a);
    scanf("%d", &b);
    
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[,]");
    while (token) {
        if (strlen(token) > 0 && token[0] != '\n') {
            list2Vals[size2++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    struct ListNode* list1 = arrayToList(list1Vals, size1);
    struct ListNode* list2 = arrayToList(list2Vals, size2);
    
    struct ListNode* result = solution(list1, a, b, list2);
    
    int output[2000];
    int outputSize = listToArray(result, output);
    
    printf("[");
    for (int i = 0; i < outputSize; i++) {
        printf("%d", output[i]);
        if (i < outputSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

One pass to convert each list to array, one pass to rebuild

✓ Linear Growth

Space Complexity

O(n + m)

Arrays to store all node values from both lists

⚡ Linearithmic Space

32.5K Views

Medium Frequency

~15 min Avg. Time

892 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 - Array Conversion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler