Insert a linked list into another linked list

Last Updated : 04 Sep, 2024

Given two linked lists, head1 and head2 of sizes m and n respectively. The task is to remove head1's nodes from the a^th node to the b^th node and insert head2 in their place.

Examples:

Input: a = 3, b = 4
head1: 10 -> 11 -> 12 -> 13 -> 14 -> 15, head2: 100 -> 101 -> 102 -> 103
Output: 10 -> 11 -> 12 -> 100 -> 101 -> 102 -> 103 -> 15

Explanation: Remove the nodes from 3rd index till 4th index from head1 and insert head2 at their place.
Input: a = 0, b = 1
head1: 1 -> 2 , head2: 3 -> 4
Output: 3 -> 4
Explanation: Remove the nodes from 0th index till 1th index from head1 and insert head2 at their place.

Approach :

The idea is to start traversing from head1 and identify the node at position a - 1 and b. Let prev points to (a-1)th node and curr points to bth node in head1. Now update the pointer as following:
Update prev's next to point to head2 node as we need to remove some nodes in head1 after prev.
Start traversing head2 until we reach to end, and update the next pointer of the end node of head2 to curr's next. This will remove the node from a to b in head1.

C++

// C++ code to insert a linked list into 
// another linked list
#include <iostream>
using namespace std;

class Node {
  public:
    int data;
    Node *next;

    Node(int x) {
        data = x;
        next = nullptr;
    }
};

// Function to merge head2 into head1 by removing nodes
// from the ath to the bth position and inserting head2
Node *mergeInBetween(Node *head1, int a, int b, Node *head2) {
    Node *curr = head1;
    Node *prev = nullptr;

    // Traverse to the node just before position
  	// 'a' and the node at position 'b'
    for (int i = 0; curr != nullptr; ++i) {
        if (i == a - 1) {
          
            // Node just before position 'a'
            prev = curr;
        }
        if (i == b) {

            // Update the next pointer of the
          	// node at position 'a - 1'
            prev->next = head2;

            // Traverse to the end of head2
            Node *endHead2 = head2;
            while (endHead2->next != nullptr) {
                endHead2 = endHead2->next;
            }

            // Connect the end of head2 to the 
          	// node after position 'b'
            endHead2->next = curr->next;
            break;
        }
        curr = curr->next;
    }

    return head1;
}

void printList(Node *head) {
    Node *curr = head;
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}

int main() {
  
    // Creating head1: 10 -> 11 -> 12 -> 13 -> 14 -> 15
    Node *head1 = new Node(10);
    head1->next = new Node(11);
    head1->next->next = new Node(12);
    head1->next->next->next = new Node(13);
    head1->next->next->next->next = new Node(14);
    head1->next->next->next->next->next = new Node(15);

    // Creating head2: 100 -> 101 -> 102 -> 103
    Node *head2 = new Node(100);
    head2->next = new Node(101);
    head2->next->next = new Node(102);
    head2->next->next->next = new Node(103);

    head1 = mergeInBetween(head1, 3, 4, head2);
    printList(head1);

    return 0;
}

 
// C++ code to insert a linked list into 
// another linked list
#include <iostream>
using namespace std;
​
class Node {
  public:
    int data;
    Node *next;
​
    Node(int x) {
        data = x;
        next = nullptr;
    }
};
​
// Function to merge head2 into head1 by removing nodes
// from the ath to the bth position and inserting head2
Node *mergeInBetween(Node *head1, int a, int b, Node *head2) {
    Node *curr = head1;
    Node *prev = nullptr;
​
    // Traverse to the node just before position
    // 'a' and the node at position 'b'
    for (int i = 0; curr != nullptr; ++i) {
        if (i == a - 1) {
          
            // Node just before position 'a'
            prev = curr;
        }
        if (i == b) {
​
            // Update the next pointer of the
            // node at position 'a - 1'
            prev->next = head2;
​
            // Traverse to the end of head2
            Node *endHead2 = head2;
            while (endHead2->next != nullptr) {
                endHead2 = endHead2->next;
            }
​
            // Connect the end of head2 to the 
            // node after position 'b'
            endHead2->next = curr->next;
            break;
        }
        curr = curr->next;
    }
​
    return head1;
}
​
void printList(Node *head) {
    Node *curr = head;
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}
​
int main() {
  
    // Creating head1: 10 -> 11 -> 12 -> 13 -> 14 -> 15
    Node *head1 = new Node(10);
    head1->next = new Node(11);
    head1->next->next = new Node(12);
    head1->next->next->next = new Node(13);
    head1->next->next->next->next = new Node(14);
    head1->next->next->next->next->next = new Node(15);
​
    // Creating head2: 100 -> 101 -> 102 -> 103
    Node *head2 = new Node(100);
    head2->next = new Node(101);
    head2->next->next = new Node(102);
    head2->next->next->next = new Node(103);
​
    head1 = mergeInBetween(head1, 3, 4, head2);
    printList(head1);
​
    return 0;
}

// C code to insert a linked list into 
// another linked list

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

struct Node {
    int data;
    struct Node *next;
};

// Function to merge head2 into head1 by removing nodes 
// from the ath to the bth position and inserting head2
struct Node* mergeInBetween(struct Node* head1, int a, int b, 
                             struct Node* head2) {
    struct Node* curr = head1;
    struct Node* prev = NULL;

    // Traverse to the node just before position 'a' and 
    // the node at position 'b'
    for (int i = 0; curr != NULL; ++i) {
        if (i == a - 1) {
          
            // Node just before position 'a'
            prev = curr; 
        }
        if (i == b) {
          
            // Update the next pointer of the node
            // at position 'a - 1'
            prev->next = head2;

            // Traverse to the end of head2
            struct Node* endHead2 = head2;
            while (endHead2->next != NULL) {
                endHead2 = endHead2->next;
            }
            
            // Connect the end of head2 to the 
            // node after position 'b'
            endHead2->next = curr->next;
            break;
        }
        curr = curr->next;
    }

    return head1;
}

void printList(struct Node* head) {
    struct Node* curr = head;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

struct Node* createNode(int x) {
    struct Node* newNode = 
      (struct Node*)malloc(sizeof(struct Node));
    newNode->data = x;
    newNode->next = NULL;
    return newNode;
}

int main() {
  
    // Creating head1: 10 -> 11 -> 12 -> 13 -> 14 -> 15
    struct Node* head1 = createNode(10);
    head1->next = createNode(11);
    head1->next->next = createNode(12);
    head1->next->next->next = createNode(13);
    head1->next->next->next->next = createNode(14);
    head1->next->next->next->next->next = createNode(15);

    // Creating head2: 100 -> 101 -> 102 -> 103
    struct Node* head2 = createNode(100);
    head2->next = createNode(101);
    head2->next->next = createNode(102);
    head2->next->next->next = createNode(103);

    head1 = mergeInBetween(head1, 3, 4, head2);
    printList(head1);

    return 0;
}

Java

// Java code to insert a linked list
// into another linked list

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class GfG {

    // Function to merge head2 into head1 by removing nodes
    // from the ath to the bth position and inserting head2
    static Node mergeInBetween(Node head1, int a, int b, Node head2) {
        Node curr = head1;
        Node prev = null;

        // Traverse to the node just before position
        // 'a' and the node at position 'b'
        for (int i = 0; curr != null; ++i) {
            if (i == a - 1) {
                prev = curr;
            }
            if (i == b) {
              
                // Update the next pointer of the node at
                // position 'a - 1'
                prev.next = head2;

                // Traverse to the end of head2
                Node endHead2 = head2;
                while (endHead2.next != null) {
                    endHead2 = endHead2.next;
                }

                // Connect the end of head2 to the node
                // after position 'b'
                endHead2.next = curr.next;
                break;
            }
            curr = curr.next;
        }

        return head1;
    }

    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {

        // Creating head1: 10 -> 11 -> 12 -> 13 -> 14 -> 15
        Node head1 = new Node(10);
        head1.next = new Node(11);
        head1.next.next = new Node(12);
        head1.next.next.next = new Node(13);
        head1.next.next.next.next = new Node(14);
        head1.next.next.next.next.next = new Node(15);

        // Creating head2: 100 -> 101 -> 102 -> 103
        Node head2 = new Node(100);
        head2.next = new Node(101);
        head2.next.next = new Node(102);
        head2.next.next.next = new Node(103);

        head1 = mergeInBetween(head1, 3, 4, head2);
        printList(head1);
    }
}

Python

# Python code to insert a linked list
# into another linked list
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def merge_in_between(head1, a, b, head2):
    curr = head1
    prev = None

    # Traverse to the node just before 
    # position 'a' and the node at position 'b'
    for i in range(b + 1):
        if i == a - 1:
            prev = curr
        if i == b:
          
            # Update the next pointer of 
            # the node at position 'a - 1'
            prev.next = head2

            # Traverse to the end of head2
            end_head2 = head2
            while end_head2.next:
                end_head2 = end_head2.next

            # Connect the end of head2 
            # to the node after position 'b'
            end_head2.next = curr.next
            break
        curr = curr.next

    return head1
  
def print_list(head):
    curr = head
    while curr:
        print(curr.data, end=" ")
        curr = curr.next
    print()

if __name__ == "__main__":
  
    # Creating head1:
    # 10 -> 11 -> 12 -> 13 -> 14 -> 15
    head1 = Node(10)
    head1.next = Node(11)
    head1.next.next = Node(12)
    head1.next.next.next = Node(13)
    head1.next.next.next.next = Node(14)
    head1.next.next.next.next.next = Node(15)

    # Creating head2: 100 -> 101 -> 102 -> 103
    head2 = Node(100)
    head2.next = Node(101)
    head2.next.next = Node(102)
    head2.next.next.next = Node(103)

    head1 = merge_in_between(head1, 3, 4, head2)
    print_list(head1)

// C# code to insert a linked list
// into another linked list

using System;

class Node {
    public int data;
    public Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class GfG {

    // Function to merge head2 into head1 by removing nodes
    // from the ath to the bth position and inserting head2
    static Node MergeInBetween(Node head1, int a,
                                      int b, Node head2) {
        Node curr = head1;
        Node prev = null;

        // Traverse to the node just before position 'a' and
        // the node at position 'b'
        for (int i = 0; curr != null; ++i) {
            if (i == a - 1) {
                prev = curr;
            }
            if (i == b) {
              
                // Update the next pointer of the node at
                // position 'a - 1'
                prev.next = head2;

                // Traverse to the end of head2
                Node endHead2 = head2;
                while (endHead2.next != null) {
                    endHead2 = endHead2.next;
                }

                // Connect the end of head2 to the node
                // after position 'b'
                endHead2.next = curr.next;
                break;
            }
            curr = curr.next;
        }

        return head1;
    }

    static void PrintList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data + " ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    static void Main() {
      
        // Creating head1: 10 -> 11 -> 12 -> 13 -> 14 -> 15
        Node head1 = new Node(10);
        head1.next = new Node(11);
        head1.next.next = new Node(12);
        head1.next.next.next = new Node(13);
        head1.next.next.next.next = new Node(14);
        head1.next.next.next.next.next = new Node(15);

        // Creating head2: 100 -> 101 -> 102 -> 103
        Node head2 = new Node(100);
        head2.next = new Node(101);
        head2.next.next = new Node(102);
        head2.next.next.next = new Node(103);

        head1 = MergeInBetween(head1, 3, 4, head2);
        PrintList(head1);
    }
}

JavaScript

// JavaScript code to insert a linked list into another
// linked list

class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

// Function to merge head2 into head1 by removing nodes
// from the ath to the bth position and inserting head2
function mergeInBetween(head1, a, b, head2) {
    let curr = head1;
    let prev = null;

    // Traverse to the node just before position 'a' and the
    // node at position 'b'
    for (let i = 0; curr !== null; ++i) {
        if (i === a - 1) {
            prev = curr;
        }
        if (i === b) {
        
            // Update the next pointer of the node at
            // position 'a - 1'
            prev.next = head2;

            // Traverse to the end of head2
            let endHead2 = head2;
            while (endHead2.next !== null) {
                endHead2 = endHead2.next;
            }

            // Connect the end of head2 to the node after
            // position 'b'
            endHead2.next = curr.next;
            break;
        }
        curr = curr.next;
    }

    return head1;
}

function printList(head) {
    let curr = head;
    while (curr !== null) {
        console.log(curr.data + " ");
        curr = curr.next;
    }
    console.log();
}

// Creating head1: 10 -> 11 -> 12 -> 13 -> 14 -> 15
let head1 = new Node(10);
head1.next = new Node(11);
head1.next.next = new Node(12);
head1.next.next.next = new Node(13);
head1.next.next.next.next = new Node(14);
head1.next.next.next.next.next = new Node(15);

// Creating head2: 100 -> 101 -> 102 -> 103
let head2 = new Node(100);
head2.next = new Node(101);
head2.next.next = new Node(102);
head2.next.next.next = new Node(103);

head1 = mergeInBetween(head1, 3, 4, head2);
printList(head1);

Output

10 11 12 100 101 102 103 15

Time Complexity: O(m + n), m is the length of head1 and n is the length of head2.
Auxiliary Space: O(1)

Software Developer (SDE) Interview/Placement Preparation Guide

rexomkar

Improve

Article Tags :

Practice Tags :

Linked List

Insert a linked list into another linked list

Similar Reads

Interview Preparation

Practice @Geeksforgeeks

Data Structures

Algorithms

Programming Languages

Web Technologies

Computer Science Subjects

Data Science & ML

Tutorial Library

GATE CS

Thank You!

What kind of Experience do you want to share?

Log in

Create Account