Merge odd and even positioned nodes of two Linked Lists alternately

19 Jan, 2022
Given two linked lists L1 and L2, the task is to print a new list obtained by merging odd position nodes of L1 with the even positioned nodes of L2 alternately.
Examples:
Input: L1 =  8->5->3->2->10->NULL, L2 = 11->13->1->6->9->NULLOutput: 8->13->3->6->10->NULL Explanation:The odd positioned nodes of L1 are {8, 3, 10} and the even positioned nodes L2 are {13, 6}. Merging them alternately generates the linked list 8->13->3->6->10->NULL
Input: L1 = 1->5->10->12->13->19->6->NULL, L2 = 2->7->9->NULL  Output: 1->7->10->13->6->NULLExplanation:The odd positioned nodes of L1 are {1, 10, 13, 6} and the even positioned node of L2 is {7}.Merging them alternately generates the linked list 1->7->10->13->6->NULL
 Approach: Follow the steps below to solve the problem:
Start traversing from the first node of L1 and for the second node of L2 simultaneously.
Add the first node of L1 to the resultant list and connect it with the second node of L2 and move to the next odd node in L1. Similarly, add connect the second node of L2 to the current odd node of L1 and move to the next even node in L2.
Repeat the above step until the end of one of the lists is reached.
Traverse the other list and keep adding the required nodes from that list to the resultant list.
Finally, print the resultant list.
 Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program to implement// the above approach #include <bits/stdc++.h>using namespace std; // Structure of a Nodeclass node {public:    int data;    node* next;    node(int d)    {        data = d;        next = NULL;    }}; // Function to insert the node// at the head of the linkedlistvoid insert_at_head(node*& head, int data){    node* n = new node(data);    n->next = head;    head = n;    return;} // Function to print the linked listvoid print(node* head){    while (head != NULL) {        cout << head->data << " ";        head = head->next;    }    cout << endl;    return;} // Function to merge the odd and// even positioned nodes of two// given linked lists alternatelynode* merge_alternate(node* head1, node* head2){    // Traverse from the second    // node of second linked list    if (head2)        head2 = head2->next;     // Stores the head of    // the resultant list    node* head3 = NULL;     // Stores the current node    node* cur = NULL;     // Store the first node of    // first list in the result    if (head1)        head3 = head1;     // Otherwise    else        head3 = head2;     // Traverse until end of a    // one of the list is reached    while (head1 != NULL && head2 != NULL) {         // If there is a previous node then        // connect that with the current node        if (cur)            cur->next = head1;         // Update the current node        cur = head1;         // If next odd node exists        if (head1->next != NULL)             // Store the next odd node            head1 = head1->next->next;         // Otherwise        else             // Reach end of list            head1 = NULL;         // Connect the first node        // with the second node        cur->next = head2;         // Update the current node        cur = head2;         // If next even node exists        if (head2->next != NULL)             // Store the next even node            head2 = head2->next->next;         // Otherwise        else             // Reach the end of the list            head2 = NULL;    }     // If end of the second    // list has been reached    while (head1 != NULL) {         // Connect with the        // previous node        if (cur)            cur->next = head1;         // Update the current node        cur = head1;         // If next odd node exists        if (head1->next != NULL)             // Store the next odd node            head1 = head1->next->next;         // Otherwise        else             // Reach end of list            head1 = NULL;    }     // If end of second list    // has been reached    while (head2 != NULL) {         // Connect with the        // previous node        if (cur)            cur->next = head2;         // Update the current node        cur = head2;         // If next even node exists        if (head2->next != NULL)             // Store the next odd node            head2 = head2->next->next;         // Otherwise        else             // Reach end of list            head2 = NULL;    }     // End of the resultant list    if (cur)        cur->next = NULL;     // Returning the head of    // the resultant node    return head3;} // Driver Codeint main(){    node *head1 = NULL, *head2 = NULL;     // Create linked list    insert_at_head(head1, 6);    insert_at_head(head1, 19);    insert_at_head(head1, 13);    insert_at_head(head1, 12);    insert_at_head(head1, 10);    insert_at_head(head1, 5);    insert_at_head(head1, 1);     insert_at_head(head2, 9);    insert_at_head(head2, 7);    insert_at_head(head2, 2);     // Merging the linked lists    head1 = merge_alternate(head1, head2);     print(head1);}
// Java program to implement// the above approachimport java.util.*;class GFG{ // Structure of a Nodestatic class node{  public int data;  node next;  node(int d)  {    data = d;    next = null;  }}; // Function to insert the node// at the head of the linkedliststatic node insert_at_head(node head,                           int data){  node n = new node(data);  n.next = head;  head = n;  return head;} // Function to print the linked liststatic void print(node head){  while (head != null)  {    System.out.print(head.data + " ");    head = head.next;  }  System.out.println();  return;} // Function to merge the odd and// even positioned nodes of two// given linked lists alternatelystatic node merge_alternate(node head1,                            node head2){  // Traverse from the second  // node of second linked list  if (head2 != null)    head2 = head2.next;   // Stores the head of  // the resultant list  node head3 = null;   // Stores the current node  node cur = null;   // Store the first node of  // first list in the result  if (head1 != null)    head3 = head1;   // Otherwise  else    head3 = head2;   // Traverse until end of a  // one of the list is reached  while (head1 != null && head2 != null)  {    // If there is a previous node then    // connect that with the current node    if (cur != null)      cur.next = head1;     // Update the current node    cur = head1;     // If next odd node exists    if (head1.next != null)       // Store the next odd node      head1 = head1.next.next;     // Otherwise    else       // Reach end of list      head1 = null;     // Connect the first node    // with the second node    cur.next = head2;     // Update the current node    cur = head2;     // If next even node exists    if (head2.next != null)       // Store the next even node      head2 = head2.next.next;     // Otherwise    else       // Reach the end of the list      head2 = null;  }   // If end of the second  // list has been reached  while (head1 != null)  {    // Connect with the    // previous node    if (cur != null)      cur.next = head1;     // Update the current node    cur = head1;     // If next odd node exists    if (head1.next != null)       // Store the next odd node      head1 = head1.next.next;     // Otherwise    else       // Reach end of list      head1 = null;  }   // If end of second list  // has been reached  while (head2 != null)  {    // Connect with the    // previous node    if (cur != null)      cur.next = head2;     // Update the current node    cur = head2;     // If next even node exists    if (head2.next != null)       // Store the next odd node      head2 = head2.next.next;     // Otherwise    else       // Reach end of list      head2 = null;  }   // End of the resultant list  if (cur != null)    cur.next = null;   // Returning the head of  // the resultant node  return head3;} // Driver Codepublic static void main(String[] args){  node head1 = null, head2 = null;   // Create linked list  head1 = insert_at_head(head1, 6);  head1 = insert_at_head(head1, 19);  head1 = insert_at_head(head1, 13);  head1 = insert_at_head(head1, 12);  head1 = insert_at_head(head1, 10);  head1 = insert_at_head(head1, 5);  head1 = insert_at_head(head1, 1);   head2 = insert_at_head(head2, 9);  head2 = insert_at_head(head2, 7);  head2 = insert_at_head(head2, 2);   // Merging the linked lists  head1 = merge_alternate(head1, head2);   print(head1);}} // This code is contributed by gauravrajput1
# Python3 program to implement# the above approach  # Structure of a Nodeclass node:         def __init__(self, d):             self.data = d;        self.next = None;     # Function to insert the node# at the head of the linkedlistdef insert_at_head(head, data):     n = node(data);    n.next = head;    head = n;    return head;  # Function to print the linked listdef printx(head):     while (head != None):        print(head.data, end = ' ')        head = head.next;         print()         return;  # Function to merge the odd and# even positioned nodes of two# given linked lists alternatelydef merge_alternate(head1, head2):     # Traverse from the second    # node of second linked list    if (head2):        head2 = head2.next;      # Stores the head of    # the resultant list    head3 = None;      # Stores the current node    cur = None;      # Store the first node of    # first list in the result    if (head1):        head3 = head1;      # Otherwise    else:        head3 = head2;      # Traverse until end of a    # one of the list is reached    while (head1 != None and head2 != None):          # If there is a previous node then        # connect that with the current node        if (cur):            cur.next = head1;          # Update the current node        cur = head1;          # If next odd node exists        if (head1.next != None):              # Store the next odd node            head1 = head1.next.next;          # Otherwise        else:              # Reach end of list            head1 = None;          # Connect the first node        # with the second node        cur.next = head2;          # Update the current node        cur = head2;          # If next even node exists        if (head2.next != None):              # Store the next even node            head2 = head2.next.next;          # Otherwise        else:              # Reach the end of the list            head2 = None;           # If end of the second    # list has been reached    while (head1 != None):          # Connect with the        # previous node        if (cur):            cur.next = head1;          # Update the current node        cur = head1;          # If next odd node exists        if (head1.next != None):              # Store the next odd node            head1 = head1.next.next;          # Otherwise        else:                # Reach end of list            head1 = None;      # If end of second list    # has been reached    while (head2 != None):          # Connect with the        # previous node        if (cur):            cur.next = head2;          # Update the current node        cur = head2;          # If next even node exists        if (head2.next != None):              # Store the next odd node            head2 = head2.next.next;          # Otherwise        else:              # Reach end of list            head2 = None;      # End of the resultant list    if (cur):        cur.next = None;      # Returning the head of    # the resultant node    return head3;   # Driver Codeif __name__=='__main__':         head1 = None    head2 = None;      # Create linked list    head1 = insert_at_head(head1, 6);    head1 = insert_at_head(head1, 19);    head1 = insert_at_head(head1, 13);    head1 = insert_at_head(head1, 12);    head1 = insert_at_head(head1, 10);    head1 = insert_at_head(head1, 5);    head1 = insert_at_head(head1, 1);      head2 = insert_at_head(head2, 9);    head2 = insert_at_head(head2, 7);    head2 = insert_at_head(head2, 2)      # Merging the linked lists    head1 = merge_alternate(head1, head2);      printx(head1);   # This code is contributed by rutvik_56
// C# program to implement// the above approachusing System;class GFG{ // Structure of a Nodeclass node{  public int data;  public node next;  public node(int d)  {    data = d;    next = null;  }}; // Function to insert the node// at the head of the linkedliststatic node insert_at_head(node head,                           int data){  node n = new node(data);  n.next = head;  head = n;  return head;} // Function to print the linked liststatic void print(node head){  while (head != null)  {    Console.Write(head.data + " ");    head = head.next;  }     Console.WriteLine();  return;} // Function to merge the odd and// even positioned nodes of two// given linked lists alternatelystatic node merge_alternate(node head1,                            node head2){  // Traverse from the second  // node of second linked list  if (head2 != null)    head2 = head2.next;   // Stores the head of  // the resultant list  node head3 = null;   // Stores the current node  node cur = null;   // Store the first node of  // first list in the result  if (head1 != null)    head3 = head1;   // Otherwise  else    head3 = head2;   // Traverse until end of a  // one of the list is reached  while (head1 != null &&         head2 != null)  {    // If there is a previous    // node then connect that    // with the current node    if (cur != null)      cur.next = head1;     // Update the current node    cur = head1;     // If next odd node exists    if (head1.next != null)       // Store the next odd node      head1 = head1.next.next;     // Otherwise    else       // Reach end of list      head1 = null;     // Connect the first node    // with the second node    cur.next = head2;     // Update the current node    cur = head2;     // If next even node exists    if (head2.next != null)       // Store the next even node      head2 = head2.next.next;     // Otherwise    else       // Reach the end of the list      head2 = null;  }   // If end of the second  // list has been reached  while (head1 != null)  {    // Connect with the    // previous node    if (cur != null)      cur.next = head1;     // Update the current node    cur = head1;     // If next odd node exists    if (head1.next != null)       // Store the next odd node      head1 = head1.next.next;     // Otherwise    else       // Reach end of list      head1 = null;  }   // If end of second list  // has been reached  while (head2 != null)  {    // Connect with the    // previous node    if (cur != null)      cur.next = head2;     // Update the current node    cur = head2;     // If next even node exists    if (head2.next != null)       // Store the next odd node      head2 = head2.next.next;     // Otherwise    else       // Reach end of list      head2 = null;  }   // End of the resultant list  if (cur != null)    cur.next = null;   // Returning the head of  // the resultant node  return head3;} // Driver Codepublic static void Main(String[] args){  node head1 = null, head2 = null;   // Create linked list  head1 = insert_at_head(head1, 6);  head1 = insert_at_head(head1, 19);  head1 = insert_at_head(head1, 13);  head1 = insert_at_head(head1, 12);  head1 = insert_at_head(head1, 10);  head1 = insert_at_head(head1, 5);  head1 = insert_at_head(head1, 1);   head2 = insert_at_head(head2, 9);  head2 = insert_at_head(head2, 7);  head2 = insert_at_head(head2, 2);   // Merging the linked lists  head1 = merge_alternate(head1, head2);   print(head1);}} // This code is contributed by Princi Singh
<script>// javascript program to implement// the above approach     // Structure of a Node     class node {         constructor(d) {            this.data = d;            this.next = null;        }    }    // Function to insert the node    // at the head of the linkedlist    function insert_at_head( head , data) {         n = new node(data);        n.next = head;        head = n;        return head;    }     // Function to print the linked list    function print( head) {        while (head != null) {            document.write(head.data + " ");            head = head.next;        }        document.write();        return;    }     // Function to merge the odd and    // even positioned nodes of two    // given linked lists alternately    function merge_alternate( head1,  head2) {        // Traverse from the second        // node of second linked list        if (head2 != null)            head2 = head2.next;         // Stores the head of        // the resultant list         head3 = null;         // Stores the current node         cur = null;         // Store the first node of        // first list in the result        if (head1 != null)            head3 = head1;         // Otherwise        else            head3 = head2;         // Traverse until end of a        // one of the list is reached        while (head1 != null && head2 != null) {            // If there is a previous node then            // connect that with the current node            if (cur != null)                cur.next = head1;             // Update the current node            cur = head1;             // If next odd node exists            if (head1.next != null)                 // Store the next odd node                head1 = head1.next.next;             // Otherwise            else                 // Reach end of list                head1 = null;             // Connect the first node            // with the second node            cur.next = head2;             // Update the current node            cur = head2;             // If next even node exists            if (head2.next != null)                 // Store the next even node                head2 = head2.next.next;             // Otherwise            else                 // Reach the end of the list                head2 = null;        }         // If end of the second        // list has been reached        while (head1 != null) {            // Connect with the            // previous node            if (cur != null)                cur.next = head1;             // Update the current node            cur = head1;             // If next odd node exists            if (head1.next != null)                 // Store the next odd node                head1 = head1.next.next;             // Otherwise            else                 // Reach end of list                head1 = null;        }         // If end of second list        // has been reached        while (head2 != null) {            // Connect with the            // previous node            if (cur != null)                cur.next = head2;             // Update the current node            cur = head2;             // If next even node exists            if (head2.next != null)                 // Store the next odd node                head2 = head2.next.next;             // Otherwise            else                 // Reach end of list                head2 = null;        }         // End of the resultant list        if (cur != null)            cur.next = null;         // Returning the head of        // the resultant node        return head3;    }     // Driver Code              head1 = null, head2 = null;         // Create linked list        head1 = insert_at_head(head1, 6);        head1 = insert_at_head(head1, 19);        head1 = insert_at_head(head1, 13);        head1 = insert_at_head(head1, 12);        head1 = insert_at_head(head1, 10);        head1 = insert_at_head(head1, 5);        head1 = insert_at_head(head1, 1);         head2 = insert_at_head(head2, 9);        head2 = insert_at_head(head2, 7);        head2 = insert_at_head(head2, 2);         // Merging the linked lists        head1 = merge_alternate(head1, head2);         print(head1); // This code is contributed by umadevi9616</script>
1 7 10 13 6
 
Time Complexity: O(N)Auxiliary Space: O(1)
GauravRajput1
princi singh
rutvik_56
umadevi9616
arorakashish0911
Data Structures
Linked List
Data Structures
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
What is Hashing | A Complete Tutorial
Find if there is a path between two vertices in an undirected graph
What is Data Structure: Types, Classifications and Applications
TCS NQT Coding Sheet
Linked List | Set 1 (Introduction)
Linked List | Set 2 (Inserting a node)
Reverse a linked list
Stack Data Structure (Introduction and Program)
Linked List | Set 3 (Deleting a node)