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->NULLInput: 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++ 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);
} |
// 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 |
# Python3 program to implement # the above approach # Structure of a Node class node:
def __init__( self , d):
self .data = d;
self . next = None ;
# Function to insert the node # at the head of the linkedlist def insert_at_head(head, data):
n = node(data);
n. next = head;
head = n;
return head;
# Function to print the linked list def 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 alternately def 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 Code if __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 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 |
<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)