Merge odd and even positioned nodes of two Linked Lists alternately

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->NULL
Output: 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->NULL
Explanation:
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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Structure of a Node
class node {
public:
    int data;
    node* next;
    node(int d)
    {
        data = d;
        next = NULL;
    }
};
 
// Function to insert the node
// at the head of the linkedlist
void insert_at_head(node*& head, int data)
{
    node* n = new node(data);
    n->next = head;
    head = n;
    return;
}
 
// Function to print the linked list
void 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 alternately
node* 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 Code
int 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Structure of a Node
static class node
{
  public int data;
  node next;
  node(int d)
  {
    data = d;
    next = null;
  }
};
 
// Function to insert the node
// at the head of the linkedlist
static 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 list
static 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 alternately
static 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 Code
public 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
class GFG{
 
// Structure of a Node
class 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 linkedlist
static 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 list
static 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 alternately
static 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 Code
public 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

chevron_right


Output: 

1 7 10 13 6






 

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up


If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.