# Merge a linked list into another linked list at alternate positions

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.

Recommended Practice

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++ program to merge a linked list into another at  ` `// alternate positions  ` `#include ` `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<data<<``" "``;  ` `        ``temp = temp->next;  ` `    ``}  ` `    ``cout<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

 `// C program to merge a linked list into another at ` `// alternate positions ` `#include ` `#include ` ` `  `// A nexted list node ` `struct` `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 functions ` `int` `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

 `// Java program to merge a linked list into another at ` `// alternate positions ` `class` `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 */`

## Python3

 `# 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 functions ` `llist1 ``=` `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 LLs ` `llist1.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#

 `// C# program to merge a linked list into ` `// another at alternate positions ` `using` `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 */`

## Javascript

 ``

Output

```First Linked List:
1 2 3
4 5 6 7 8
1 4 2 5 3 6
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.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next