Codestin Search App

Merge In Between Linked Lists - Problem

Linked List Medium

Merge In Between Linked Lists is a fascinating linked list manipulation problem that tests your pointer management skills.

You are given two linked lists: list1 with n nodes and list2 with m nodes. Your task is to perform a surgical replacement operation:

🎯 Goal: Remove nodes from position a to position b (inclusive) in list1, and insert the entire list2 in their place.

Example: If list1 = [0,1,2,3,4,5], list2 = [1000000,1000001,1000002], a = 3, and b = 4, you need to:
• Remove nodes at positions 3 and 4 (values 3 and 4)
• Insert all of list2 in their place
• Result: [0,1,2,1000000,1000001,1000002,5]

This problem simulates real-world scenarios like replacing a section of code, splicing video segments, or updating parts of a document while maintaining the overall structure.

Input & Output

example_1.py — Basic Replacement

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

› Output: [0,1,2,1000000,1000001,1000002,5]

💡 Note: We remove nodes at positions 3 and 4 (values 3 and 4) and insert the entire list2 in their place. The nodes before position 3 and after position 4 remain connected.

example_2.py — Replace Single Node

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

› Output: [0,1,1000000,1000001,3,4,5,6]

💡 Note: Only one node at position 2 (value 2) is removed and replaced with the two nodes from list2.

example_3.py — Replace to End

$ Input: list1 = [0,1,2,3], list2 = [100,101,102], a = 2, b = 3

› Output: [0,1,100,101,102]

💡 Note: Remove the last two nodes (positions 2 and 3) and replace them with list2. Since there are no nodes after position 3, list2 becomes the new tail.

Constraints

The number of nodes in list1 is in the range [3, 10⁴]
The number of nodes in list2 is in the range [1, 10⁴]
1 ≤ a ≤ b < n - 1 where n is the number of nodes in list1
1 ≤ Node.val ≤ 10⁶
Important: You are guaranteed that a and b are valid positions

Visualization

Tap to expand

Understanding the Visualization

Locate Cut Points

Find the node just before position a (our anchor point) and identify what comes after position b

Make the First Cut

Disconnect the chain at position a-1, saving the reference to where we'll reconnect later

Attach New Segment

Connect the anchor point to the head of list2, effectively grafting it into the original chain

Find Exit Point

Traverse to the end of list2 to find where we need to reconnect to the original chain

Complete the Surgery

Connect the tail of list2 to the node that was originally at position b+1

Key Takeaway

🎯 Key Insight: We only need to find two critical connection points and perform two pointer operations - no extra space needed!

Asked in

a Amazon 42 ⊞ Microsoft 35 G Google 28 f Meta 22

The optimal approach uses direct pointer manipulation to splice list2 into list1. Find the node before position a, connect it to list2's head, then connect list2's tail to the node after position b. This achieves O(n+m) time with O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Pointer Manipulation (Optimal)	O(n + m)	O(1)	Find connection points and rewire pointers directly
Brute Force (Array Conversion)	O(n + m)	O(n + m)	Convert linked lists to arrays, perform operations, then rebuild

Direct Pointer Manipulation (Optimal) — Algorithm Steps

Find the node just before position a (let's call it 'prev')
Find the node at position b (let's call it 'nodeB')
Connect prev.next to the head of list2
Find the tail of list2 and connect it to nodeB.next
Return the original head of list1

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Connection Points

Locate node before position a and node after position b

Connect to List2

Point prev.next to head of list2

Find List2 Tail

Traverse to end of list2

Complete Connection

Point list2 tail to node after position b

Code -

solution.c — C

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

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

struct ListNode* mergeInBetween(struct ListNode* list1, int a, int b, struct ListNode* list2) {
    // Find node just before position a
    struct ListNode* prev = list1;
    for (int i = 0; i < a - 1; i++) {
        prev = prev->next;
    }
    
    // Find node at position b
    struct ListNode* nodeB = prev;
    for (int i = 0; i < b - a + 2; i++) {
        nodeB = nodeB->next;
    }
    
    // Connect prev to head of list2
    prev->next = list2;
    
    // Find tail of list2
    struct ListNode* tail2 = list2;
    while (tail2->next) {
        tail2 = tail2->next;
    }
    
    // Connect tail of list2 to node after b
    tail2->next = nodeB;
    
    return list1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

O(n) to find positions a and b in list1, plus O(m) to find the tail of list2

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for pointer variables

✓ Linear Space

54.2K Views

Medium Frequency

~15 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Direct Pointer Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler