Merge a linked list into another linked list at alternate positions

Last Updated : 13 Sep, 2024

Given two singly linked lists, The task is to insert nodes of the second list into the first list at alternate positions of the first list and leave the remaining nodes of the second list if it is longer.

Example:

Input: head1: 1->2->3 , head2: 4->5->6->7->8
Output: head1: 1->4->2->5->3->6 , head2: 7->8

4_1


Input: head1: 10->12->21 , head2: 3->1->4
Output: head1: 10->3->12->1->21->4, head2: <empty>

2_3
Try It Yourself
redirect icon

Using Iterative Method – O(n) Time and O(1) Space:

The idea is to start traversing from the beginning of both lists. For each step, take a node from the second list and insert it after a node from the first list. This process continues until we reach the end of one or both lists. If the second list is longer, remaining nodes will be kept as it is second list.

C++ 
// C++ program to merge a linked list into another at
// alternate positions

#include <bits/stdc++.h>
using namespace std;

class Node{
  public:
    int data;
    Node *next;
    Node(int x) {
        data = x;
        next = nullptr;
    }
};

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

// Function to merge two linked lists
vector<Node *> merge(Node *head1, Node *head2) {
  
    // Initialize pointers to traverse the two lists
    Node *curr1 = head1;
    Node *curr2 = head2;

    // Traverse both lists and merge them
    while (curr1 != NULL && curr2 != NULL){
      
        // Save the next nodes of the current 
      	// nodes in both lists
        Node *ptr1 = curr1->next;
        Node *ptr2 = curr2->next;

        // Insert the current node from the second list
        // after the current node from the first list
        curr2->next = curr1->next;
        curr1->next = curr2;

        // Update the pointers for the next iteration
        curr1 = ptr1;
        curr2 = ptr2;
    }

    return {head1, curr2};
}

int main(){
  
    // Creating first linked list 1->2->3
    Node *head1 = new Node(1);
    head1->next = new Node(2);
    head1->next->next = new Node(3);

    // crating second listed list 4->5->6->7->8
    Node *head2 = new Node(4);
    head2->next = new Node(5);
    head2->next->next = new Node(6);
    head2->next->next->next = new Node(7);
    head2->next->next->next->next = new Node(8);

    // Store first and second head points in array
    vector<Node *> ar = merge(head1, head2);
    printList(ar[0]);
    printList(ar[1]);

    return 0;
}
C 
// C program to merge a linked list into another at
// alternate positions
#include <stdio.h>
#include <stdlib.h>

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


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

// Function to merge two linked lists
struct Node *merge(struct Node *head1, struct Node *head2) {
    struct Node *curr1 = head1;
    struct Node *curr2 = head2;
    struct Node *next1, *next2;

    // Traverse both lists and merge them
    while (curr1 != NULL && curr2 != NULL) {
      
        // Save the next nodes of the current 
      	//  nodes in both lists
        next1 = curr1->next;
        next2 = curr2->next;

        // Insert the current node from the second list
      	// after the current node from the first list
        curr2->next = curr1->next;
        curr1->next = curr2;

        // Update the pointers for the next iteration
        curr1 = next1;
        curr2 = next2;
    }

    // Return the remaining part of the second list
    return curr2;
}

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

int main() {
  
    // Creating the first linked list: 1->2->3
    struct Node *head1 = createNode(1);
    head1->next = createNode(2);
    head1->next->next = createNode(3);

    // Creating the second linked list: 4->5->6->7->8
    struct Node *head2 = createNode(4);
    head2->next = createNode(5);
    head2->next->next = createNode(6);
    head2->next->next->next = createNode(7);
    head2->next->next->next->next = createNode(8);

    struct Node *remaining = merge(head1, head2);

    // Print merged list and remaining list
    printList(head1);
    printList(remaining);

    return 0;
}
Java 
// Java program to merge a linked list into another at
// alternate positions

import java.util.*;

class Node {
    int data;
    Node next;

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

class GfG {

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

    // Function to merge two linked lists
    static List<Node> merge(Node head1, Node head2) {
      
        // Initialize pointers to traverse the two lists
        Node temp1 = head1;
        Node temp2 = head2;

        // Traverse both lists and merge them
        while (temp1 != null && temp2 != null) {
          
            // Save the next nodes of the current nodes in
            // both lists
            Node ptr1 = temp1.next;
            Node ptr2 = temp2.next;

            // Insert the current node from the second list
            // after the current node from the first list
            temp2.next = temp1.next;
            temp1.next = temp2;

            // Update the pointers for the next iteration
            temp1 = ptr1;
            temp2 = ptr2;
        }

        return Arrays.asList(head1, temp2);
    }

    public static void main(String[] args) {

        // Creating first linked list 1->2->3
        Node head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);

        // Creating second linked list 4->5->6->7->8
        Node head2 = new Node(4);
        head2.next = new Node(5);
        head2.next.next = new Node(6);
        head2.next.next.next = new Node(7);
        head2.next.next.next.next = new Node(8);

        // Store first and second head points in array
        List<Node> ar = merge(head1, head2);
        printList(ar.get(0));
        printList(ar.get(1));
    }
}
Python 
# Python program to merge a linked list into another at
# alternate positions
class Node:
    def __init__(self, x):
        self.data = x
        self.next = None


def printList(head):
    curr = head
    while curr:
        print(curr.data, end=" ")
        curr = curr.next
    print()

# Function to merge two linked lists
def merge(head1, head2):
  
    # Initialize pointers to traverse the two lists
    temp1 = head1
    temp2 = head2

    # Traverse both lists and merge them
    while temp1 is not None and temp2 is not None:
      
        # Save the next nodes of the current
        # nodes in both lists
        ptr1 = temp1.next
        ptr2 = temp2.next

        # Insert the current node from the second list
        # after the current node from the first list
        temp2.next = temp1.next
        temp1.next = temp2

        # Update the pointers for the next iteration
        temp1 = ptr1
        temp2 = ptr2

    return [head1, temp2]


if __name__ == "__main__":
  
    # Creating first linked list 1->2->3
    head1 = Node(1)
    head1.next = Node(2)
    head1.next.next = Node(3)

    # Creating second linked list 4->5->6->7->8
    head2 = Node(4)
    head2.next = Node(5)
    head2.next.next = Node(6)
    head2.next.next.next = Node(7)
    head2.next.next.next.next = Node(8)

    # Store first and second head points in array
    ar = merge(head1, head2)
    printList(ar[0])
    printList(ar[1])
C# 
// C# program to merge a linked list into
// another at alternate positions

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node next;

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

class GfG {

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

    // Function to merge two linked lists
    static List<Node> Merge(Node head1, Node head2) {
      
        // Initialize pointers to traverse the two lists
        Node temp1 = head1;
        Node temp2 = head2;

        // Traverse both lists and merge them
        while (temp1 != null && temp2 != null) {
          
            // Save the next nodes of the current nodes in
            // both lists
            Node ptr1 = temp1.next;
            Node ptr2 = temp2.next;

            // Insert the current node from the second list
            // after the current node from the first list
            temp2.next = temp1.next;
            temp1.next = temp2;

            // Update the pointers for the next iteration
            temp1 = ptr1;
            temp2 = ptr2;
        }

        return new List<Node>{ head1, temp2 };
    }

    static void Main(string[] args) {
      
        // Creating first linked list 1->2->3
        Node head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);

        // Creating second linked list 4->5->6->7->8
        Node head2 = new Node(4);
        head2.next = new Node(5);
        head2.next.next = new Node(6);
        head2.next.next.next = new Node(7);
        head2.next.next.next.next = new Node(8);

        // Store first and second head points in array
        List<Node> ar = Merge(head1, head2);
        PrintList(ar[0]);
        PrintList(ar[1]);
    }
}
JavaScript 
// Javascript program to merge a linked list
// into another at alternate positions

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

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

// Function to merge two linked lists
function merge(head1, head2) {

    // Initialize pointers to traverse the two lists
    let temp1 = head1;
    let temp2 = head2;

    // Traverse both lists and merge them
    while (temp1 !== null && temp2 !== null) {
    
        // Save the next nodes of the current nodes in both
        // lists
        let ptr1 = temp1.next;
        let ptr2 = temp2.next;

        // Insert the current node from the second list
        // after the current node from the first list
        temp2.next = temp1.next;
        temp1.next = temp2;

        // Update the pointers for the next iteration
        temp1 = ptr1;
        temp2 = ptr2;
    }

    return [ head1, temp2 ];
}

// Creating first linked list 1->2->3
let head1 = new Node(1);
head1.next = new Node(2);
head1.next.next = new Node(3);

// Creating second linked list 4->5->6->7->8
let head2 = new Node(4);
head2.next = new Node(5);
head2.next.next = new Node(6);
head2.next.next.next = new Node(7);
head2.next.next.next.next = new Node(8);

// Store first and second head points in array
let ar = merge(head1, head2);
printList(ar[0]);
printList(ar[1]);

Output
1 4 2 5 3 6 
7 8

Time Complexity: O(min(n1, n2)), where n1 and n2 represents the length of the given two linked lists.
Auxiliary Space: O(1).

Comment
Article Tags:
Linked List
DSA
Amazon

Explore