Merge a linked list into another linked list at alternate positions

03 Jul, 2022
Given two linked lists, insert nodes of second list into first list at alternate positions of first list. For example, if first list is 5->7->17->13->11 and second is 12->10->2->4->6, the first list should become 5->12->7->10->17->2->13->4->11->6 and second list should become empty. The nodes of second list should only be inserted when there are positions available. For example, if the first list is 1->2->3 and second list is 4->5->6->7->8, then first list should become 1->4->2->5->3->6 and second list to 7->8.
Use of extra space is not allowed (Not allowed to create additional nodes), i.e., insertion must be done in-place. Expected time complexity is O(n) where n is number of nodes in first list. 
The idea is to run a loop while there are available positions in first loop and insert nodes of second list by changing pointers.
Following are implementations of this approach. 
C++
C
Java
Python3
C#
Javascript
// C++ program to merge a linked list into another at // alternate positions #include <bits/stdc++.h>using namespace std;  // A nexted list node class Node {     public:    int data;     Node *next; };   /* Function to insert a node at the beginning */void push(Node ** head_ref, int new_data) {     Node* new_node = new Node();    new_node->data = new_data;     new_node->next = (*head_ref);     (*head_ref) = new_node; }   /* Utility function to print a singly linked list */void printList(Node *head) {     Node *temp = head;     while (temp != NULL)     {         cout<<temp->data<<" ";         temp = temp->next;     }     cout<<endl;}   // Main function that inserts nodes of linked list q into p at // alternate positions. Since head of first list never changes // and head of second list may change, we need single pointer // for first list and double pointer for second list. void merge(Node *p, Node **q) {     Node *p_curr = p, *q_curr = *q;     Node *p_next, *q_next;       // While there are available positions in p     while (p_curr != NULL && q_curr != NULL)     {         // Save next pointers         p_next = p_curr->next;         q_next = q_curr->next;           // Make q_curr as next of p_curr         q_curr->next = p_next; // Change next pointer of q_curr         p_curr->next = q_curr; // Change next pointer of p_curr           // Update current pointers for next iteration         p_curr = p_next;         q_curr = q_next;     }       *q = q_curr; // Update head pointer of second list }   // Driver code int main() {     Node *p = NULL, *q = NULL;     push(&p, 3);     push(&p, 2);     push(&p, 1);     cout<<"First Linked List:\n";     printList(p);       push(&q, 8);     push(&q, 7);     push(&q, 6);     push(&q, 5);     push(&q, 4);     cout<<"Second Linked List:\n";     printList(q);       merge(p, &q);       cout<<"Modified First Linked List:\n";     printList(p);       cout<<"Modified Second Linked List:\n";     printList(q);       return 0; }   // This code is contributed by rathbhupendra
// C program to merge a linked list into another at// alternate positions#include <stdio.h>#include <stdlib.h>  // A nexted list nodestruct Node{    int data;    struct Node *next;};  /* Function to insert a node at the beginning */void push(struct Node ** head_ref, int new_data){    struct Node* new_node =            (struct Node*) malloc(sizeof(struct Node));    new_node->data  = new_data;    new_node->next = (*head_ref);    (*head_ref)  = new_node;}  /* Utility function to print a singly linked list */void printList(struct Node *head){    struct Node *temp = head;    while (temp != NULL)    {        printf("%d ", temp->data);        temp = temp->next;    }    printf("\n");}  // Main function that inserts nodes of linked list q into p at // alternate positions. Since head of first list never changes // and head of second list  may change, we need single pointer// for first list and double pointer for second list.void merge(struct Node *p, struct Node **q){     struct Node *p_curr = p, *q_curr = *q;     struct Node *p_next, *q_next;       // While there are available positions in p     while (p_curr != NULL && q_curr != NULL)     {         // Save next pointers         p_next = p_curr->next;         q_next = q_curr->next;           // Make q_curr as next of p_curr         q_curr->next = p_next;  // Change next pointer of q_curr         p_curr->next = q_curr;  // Change next pointer of p_curr           // Update current pointers for next iteration         p_curr = p_next;         q_curr = q_next;    }      *q = q_curr; // Update head pointer of second list}  // Driver program to test above functionsint main(){     struct Node *p = NULL, *q = NULL;     push(&p, 3);     push(&p, 2);     push(&p, 1);     printf("First Linked List:\n");     printList(p);       push(&q, 8);     push(&q, 7);     push(&q, 6);     push(&q, 5);     push(&q, 4);     printf("Second Linked List:\n");     printList(q);       merge(p, &q);       printf("Modified First Linked List:\n");     printList(p);       printf("Modified Second Linked List:\n");     printList(q);       getchar();     return 0;}
// Java program to merge a linked list into another at// alternate positionsclass LinkedList{    Node head;  // head of list      /* Linked list Node*/    class Node    {        int data;        Node next;        Node(int d) {data = d; next = null; }    }      /* Inserts a new Node at front of the list. */    void push(int new_data)    {        /* 1 & 2: Allocate the Node &                  Put in the data*/        Node new_node = new Node(new_data);          /* 3. Make next of new Node as head */        new_node.next = head;          /* 4. Move the head to point to new Node */        head = new_node;    }      // Main function that inserts nodes of linked list q into p at    // alternate positions. Since head of first list never changes    // and head of second list/ may change, we need single pointer    // for first list and double pointer for second list.    void merge(LinkedList q)    {        Node p_curr = head, q_curr = q.head;        Node p_next, q_next;          // While there are available positions in p;        while (p_curr != null && q_curr != null) {              // Save next pointers            p_next = p_curr.next;            q_next = q_curr.next;              // make q_curr as next of p_curr            q_curr.next = p_next; // change next pointer of q_curr            p_curr.next = q_curr; // change next pointer of p_curr              // update current pointers for next iteration            p_curr = p_next;            q_curr = q_next;        }        q.head = q_curr;    }      /* Function to print linked list */    void printList()    {        Node temp = head;        while (temp != null)        {           System.out.print(temp.data+" ");           temp = temp.next;        }        System.out.println();    }      /* Driver program to test above functions */    public static void main(String args[])    {        LinkedList llist1 = new LinkedList();        LinkedList llist2 = new LinkedList();        llist1.push(3);        llist1.push(2);        llist1.push(1);          System.out.println("First Linked List:");        llist1.printList();          llist2.push(8);        llist2.push(7);        llist2.push(6);        llist2.push(5);        llist2.push(4);          System.out.println("Second Linked List:");          llist1.merge(llist2);          System.out.println("Modified first linked list:");        llist1.printList();          System.out.println("Modified second linked list:");        llist2.printList();    }} /* This code is contributed by Rajat Mishra */
# Python program to merge a linked list into another at# alternate positions  class Node(object):    def __init__(self, data:int):        self.data = data        self.next = None    class LinkedList(object):    def __init__(self):        self.head = None              def push(self, new_data:int):        new_node = Node(new_data)        new_node.next = self.head        # 4. Move the head to point to new Node        self.head = new_node              # Function to print linked list from the Head    def printList(self):        temp = self.head        while temp != None:            print(temp.data)            temp = temp.next                  # Main function that inserts nodes of linked list q into p at alternate positions.     # Since head of first list never changes    # but head of second list/ may change,     # we need single pointer for first list and double pointer for second list.    def merge(self, p, q):        p_curr = p.head        q_curr = q.head          # swap their positions until one finishes off        while p_curr != None and q_curr != None:              # Save next pointers            p_next = p_curr.next            q_next = q_curr.next              # make q_curr as next of p_curr            q_curr.next = p_next  # change next pointer of q_curr            p_curr.next = q_curr  # change next pointer of p_curr              # update current pointers for next iteration            p_curr = p_next            q_curr = q_next            q.head = q_curr      # Driver program to test above functionsllist1 = LinkedList()llist2 = LinkedList()  # Creating LLs  # 1.llist1.push(3)llist1.push(2)llist1.push(1)llist1.push(0)  # 2.for i in range(8, 3, -1):    llist2.push(i)  print("First Linked List:")llist1.printList()  print("Second Linked List:")llist2.printList()  # Merging the LLsllist1.merge(p=llist1, q=llist2)  print("Modified first linked list:")llist1.printList()  print("Modified second linked list:")llist2.printList()  # This code is contributed by Deepanshu Mehta
// C# program to merge a linked list into// another at alternate positionsusing System;  public class LinkedList {     Node head; // head of list       /* Linked list Node*/    public class Node     {         public int data;         public Node next;         public Node(int d)         {             data = d;              next = null;        }     }       /* Inserts a new Node at front of the list. */    void push(int new_data)     {         /* 1 & 2: Allocate the Node &                 Put in the data*/        Node new_node = new Node(new_data);           /* 3. Make next of new Node as head */        new_node.next = head;           /* 4. Move the head to point to new Node */        head = new_node;     }       // Main function that inserts nodes     // of linked list q into p at alternate     // positions. Since head of first list    // never changes and head of second     // list/ may change, we need single     // pointer for first list and double     // pointer for second list.     void merge(LinkedList q)     {         Node p_curr = head, q_curr = q.head;         Node p_next, q_next;           // While there are available positions in p;         while (p_curr != null && q_curr != null)        {               // Save next pointers             p_next = p_curr.next;             q_next = q_curr.next;               // make q_curr as next of p_curr             q_curr.next = p_next; // change next pointer of q_curr             p_curr.next = q_curr; // change next pointer of p_curr               // update current pointers for next iteration             p_curr = p_next;             q_curr = q_next;         }         q.head = q_curr;     }       /* Function to print linked list */    void printList()     {         Node temp = head;         while (temp != null)         {             Console.Write(temp.data+" ");             temp = temp.next;         }         Console.WriteLine();     }       /* Driver code*/    public static void Main()     {         LinkedList llist1 = new LinkedList();         LinkedList llist2 = new LinkedList();         llist1.push(3);         llist1.push(2);         llist1.push(1);           Console.WriteLine("First Linked List:");         llist1.printList();           llist2.push(8);         llist2.push(7);         llist2.push(6);         llist2.push(5);         llist2.push(4);           Console.WriteLine("Second Linked List:");           llist1.merge(llist2);           Console.WriteLine("Modified first linked list:");         llist1.printList();           Console.WriteLine("Modified second linked list:");         llist2.printList();     } }   /* This code contributed by PrinciRaj1992 */
<script>  // Javascript program to merge a linked list into another at // alternate positions   // A nexted list node class Node {     constructor()    {        this.data = 0;        this.next = null;    }};   /* Function to insert a node at the beginning */function push(head_ref, new_data) {     var new_node = new Node();    new_node.data = new_data;     new_node.next = (head_ref);     (head_ref) = new_node;    return head_ref;  }   /* Utility function to print a singly linked list */function printList(head) {     var temp = head;     while (temp != null)     {         document.write( temp.data + " ");         temp = temp.next;     }     document.write("<br>");}   // Main function that inserts nodes of linked list q into p at // alternate positions. Since head of first list never changes // and head of second list may change, we need single pointer // for first list and double pointer for second list. function merge(p, q) {     var p_curr = p, q_curr = q;     var p_next, q_next;       // While there are available positions in p     while (p_curr != null &&  q_curr != null)     {         // Save next pointers         p_next = p_curr.next;         q_next = q_curr.next;           // Make q_curr as next of p_curr         q_curr.next = p_next; // Change next pointer of q_curr         p_curr.next = q_curr; // Change next pointer of p_curr           // Update current pointers for next iteration         p_curr = p_next;         q_curr = q_next;     }       q = q_curr; // Update head pointer of second list     return q;}   // Driver code var p = null, q = null; p = push(p, 3); p = push(p, 2); p = push(p, 1); document.write( "First Linked List:<br>"); printList(p); q = push(q, 8); q = push(q, 7); q = push(q, 6); q = push(q, 5); q = push(q, 4); document.write( "Second Linked List:<br>"); printList(q); q = merge(p, q); document.write( "Modified First Linked List:<br>"); printList(p); document.write( "Modified Second Linked List:<br>"); printList(q);   // This code is contributed by rrrtnx.</script>
First Linked List:
1 2 3 
Second Linked List:
4 5 6 7 8 
Modified First Linked List:
1 4 2 5 3 6 
Modified Second Linked List:
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), no extra space is required, so it is a constant.
princiraj1992
rathbhupendra
nidhi_biet
rrrtnx
Deepanshu_mehta
sagartomar9927
sagar0719kumar
simmytarika5
samim2000
hardikkoriintern
Amazon
Linked List
Amazon
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stack Data Structure (Introduction and Program)
LinkedList in Java
Introduction to Data Structures
What is Data Structure: Types, Classifications and Applications
Implementing a Linked List in Java using Class
Detect and Remove Loop in a Linked List
Add two numbers represented by linked lists | Set 1
Queue - Linked List Implementation
Function to check if a singly linked list is palindrome
Implement a stack using singly linked list