# 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++

 `// C++ program to implement` `// the above approach`   `#include ` `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

 `// 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`

## C#

 `// 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`

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.