Related Articles

# Merge two sorted lists (in-place)

• Difficulty Level : Medium
• Last Updated : 18 May, 2021

Given two sorted lists, merge them so as to produce a combined sorted list (without using extra space).
Examples:

```Input : head1: 5->7->9
Output : 4->5->6->7->8->9
Explanation: The output list is in sorted order.

Output : 1->2->3->4->5->7
Explanation: The output list is in sorted order.```

There are different discussed different solutions in post below.

Method 1 (Recursive)

Approach: The recursive solution can be formed, given the linked lists are sorted.

2. Find the smaller node among the two head nodes. The current element will be the smaller node among two head nodes.
3. The rest elements of both lists will appear after that.
4. Now run a recursive function with parameters, the next node of the smaller element, and the other head.
5. The recursive function will return the next smaller element linked with rest of the sorted element. Now point the next of current element to that, i.e curr_ele->next=recursivefunction()
6. Handle some corner cases.
• If both the heads are NULL return null.
• If one head is null return the other.

## C++

 `// C program to merge two sorted linked lists` `// in-place.` `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `// Function to create newNode in a linkedlist` `Node* newNode(``int` `key)` `{` `    ``struct` `Node* temp = ``new` `Node;` `    ``temp->data = key;` `    ``temp->next = NULL;` `    ``return` `temp;` `}`   `// A utility function to print linked list` `void` `printList(Node* node)` `{` `    ``while` `(node != NULL) {` `        ``printf``(``"%d  "``, node->data);` `        ``node = node->next;` `    ``}` `}`   `// Merges two given lists in-place. This function` `// mainly compares head nodes and calls mergeUtil()` `Node* merge(Node* h1, Node* h2)` `{` `    ``if` `(!h1)` `        ``return` `h2;` `    ``if` `(!h2)` `        ``return` `h1;`   `    ``// start with the linked list` `    ``// whose head data is the least` `    ``if` `(h1->data < h2->data) {` `        ``h1->next = merge(h1->next, h2);` `        ``return` `h1;` `    ``}` `    ``else` `{` `        ``h2->next = merge(h1, h2->next);` `        ``return` `h2;` `    ``}` `}`   `// Driver program` `int` `main()` `{` `    ``Node* head1 = newNode(1);` `    ``head1->next = newNode(3);` `    ``head1->next->next = newNode(5);`   `    ``// 1->3->5 LinkedList created`   `    ``Node* head2 = newNode(0);` `    ``head2->next = newNode(2);` `    ``head2->next->next = newNode(4);`   `    ``// 0->2->4 LinkedList created`   `    ``Node* mergedhead = merge(head1, head2);`   `    ``printList(mergedhead);` `    ``return` `0;` `}`

## Java

 `// Java program to merge two sorted` `// linked lists in-place.` `class` `GFG {`   `    ``static` `class` `Node {` `        ``int` `data;` `        ``Node next;` `    ``};`   `    ``// Function to create newNode in a linkedlist` `    ``static` `Node newNode(``int` `key)` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.data = key;` `        ``temp.next = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// A utility function to print linked list` `    ``static` `void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``System.out.printf(``"%d "``, node.data);` `            ``node = node.next;` `        ``}` `    ``}`   `    ``// Merges two given lists in-place. This function` `    ``// mainly compares head nodes and calls mergeUtil()` `    ``static` `Node merge(Node h1, Node h2)` `    ``{` `        ``if` `(h1 == ``null``)` `            ``return` `h2;` `        ``if` `(h2 == ``null``)` `            ``return` `h1;`   `        ``// start with the linked list` `        ``// whose head data is the least` `        ``if` `(h1.data < h2.data) {` `            ``h1.next = merge(h1.next, h2);` `            ``return` `h1;` `        ``}` `        ``else` `{` `            ``h2.next = merge(h1, h2.next);` `            ``return` `h2;` `        ``}` `    ``}`   `    ``// Driver program` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``Node head1 = newNode(``1``);` `        ``head1.next = newNode(``3``);` `        ``head1.next.next = newNode(``5``);`   `        ``// 1.3.5 LinkedList created`   `        ``Node head2 = newNode(``0``);` `        ``head2.next = newNode(``2``);` `        ``head2.next.next = newNode(``4``);`   `        ``// 0.2.4 LinkedList created`   `        ``Node mergedhead = merge(head1, head2);`   `        ``printList(mergedhead);` `    ``}` `}`   `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 program to merge two ` `# sorted linked lists in-place.` `import` `math`   `class` `Node: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None`   `# Function to create newNode in a linkedlist` `def` `newNode( key):` `    ``temp ``=` `Node(key)` `    ``temp.data ``=` `key` `    ``temp.``next` `=` `None` `    ``return` `temp`   `# A utility function to print linked list` `def` `printList( node):` `    ``while` `(node !``=` `None``):` `        ``print``(node.data, end ``=` `" "``)` `        ``node ``=` `node.``next`   `# Merges two given lists in-place. ` `# This function mainly compares ` `# head nodes and calls mergeUtil()` `def` `merge( h1, h2):` `    ``if` `(h1 ``=``=` `None``):` `        ``return` `h2` `    ``if` `(h2 ``=``=` `None``):` `        ``return` `h1`   `    ``# start with the linked list` `    ``# whose head data is the least` `    ``if` `(h1.data < h2.data):` `        ``h1.``next` `=` `merge(h1.``next``, h2)` `        ``return` `h1` `    `  `    ``else``:` `        ``h2.``next` `=` `merge(h1, h2.``next``)` `        ``return` `h2` `    `  `# Driver Code` `if` `__name__``=``=``'__main__'``: ` `    ``head1 ``=` `newNode(``1``)` `    ``head1.``next` `=` `newNode(``3``)` `    ``head1.``next``.``next` `=` `newNode(``5``)`   `    ``# 1.3.5 LinkedList created` `    ``head2 ``=` `newNode(``0``)` `    ``head2.``next` `=` `newNode(``2``)` `    ``head2.``next``.``next` `=` `newNode(``4``)`   `    ``# 0.2.4 LinkedList created` `    ``mergedhead ``=` `merge(head1, head2)`   `    ``printList(mergedhead)`   `# This code is contributed by Srathore`

## C#

 `// C# program to merge two sorted` `// linked lists in-place.` `using` `System;`   `class` `GFG {`   `    ``public` `class` `Node {` `        ``public` `int` `data;` `        ``public` `Node next;` `    ``};`   `    ``// Function to create newNode in a linkedlist` `    ``static` `Node newNode(``int` `key)` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.data = key;` `        ``temp.next = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// A utility function to print linked list` `    ``static` `void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``Console.Write(``"{0} "``, node.data);` `            ``node = node.next;` `        ``}` `    ``}`   `    ``// Merges two given lists in-place. This function` `    ``// mainly compares head nodes and calls mergeUtil()` `    ``static` `Node merge(Node h1, Node h2)` `    ``{` `        ``if` `(h1 == ``null``)` `            ``return` `h2;` `        ``if` `(h2 == ``null``)` `            ``return` `h1;`   `        ``// start with the linked list` `        ``// whose head data is the least` `        ``if` `(h1.data < h2.data) {` `            ``h1.next = merge(h1.next, h2);` `            ``return` `h1;` `        ``}` `        ``else` `{` `            ``h2.next = merge(h1, h2.next);` `            ``return` `h2;` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``Node head1 = newNode(1);` `        ``head1.next = newNode(3);` `        ``head1.next.next = newNode(5);`   `        ``// 1.3.5 LinkedList created`   `        ``Node head2 = newNode(0);` `        ``head2.next = newNode(2);` `        ``head2.next.next = newNode(4);`   `        ``// 0.2.4 LinkedList created`   `        ``Node mergedhead = merge(head1, head2);`   `        ``printList(mergedhead);` `    ``}` `}`   `// This code has been contributed by 29AjayKumar`

## Javascript

 ``

Output:

`0 1 2 3 4 5 `

Complexity Analysis:

• Time complexity:O(n).
Only one traversal of the linked lists are needed.
• Auxiliary Space:O(n).
If the recursive stack space is taken into consideration.

Method 2 (Iterative)

Approach: This approach is very similar to the above recursive approach.

1. Traverse the list from start to end.
2. If the head node of second list lies in between two nodes of the first list, insert it there and make the next node of second list the head. Continue this until there is no node left in both lists, i.e. both the lists are traversed.
3. If the first list has reached end while traversing, point the next node to the head of second list.

Note: Compare both the lists where the list with a smaller head value is the first list.

## C++

 `// C++ program to merge two sorted linked lists` `// in-place.` `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `// Function to create newNode in a linkedlist` `struct` `Node* newNode(``int` `key)` `{` `    ``struct` `Node* temp = ``new` `Node;` `    ``temp->data = key;` `    ``temp->next = NULL;` `    ``return` `temp;` `}`   `// A utility function to print linked list` `void` `printList(``struct` `Node* node)` `{` `    ``while` `(node != NULL) {` `        ``printf``(``"%d  "``, node->data);` `        ``node = node->next;` `    ``}` `}`   `// Merges two lists with headers as h1 and h2.` `// It assumes that h1's data is smaller than` `// or equal to h2's data.` `struct` `Node* mergeUtil(``struct` `Node* h1,` `                       ``struct` `Node* h2)` `{` `    ``// if only one node in first list` `    ``// simply point its head to second list` `    ``if` `(!h1->next) {` `        ``h1->next = h2;` `        ``return` `h1;` `    ``}`   `    ``// Initialize current and next pointers of` `    ``// both lists` `    ``struct` `Node *curr1 = h1, *next1 = h1->next;` `    ``struct` `Node *curr2 = h2, *next2 = h2->next;`   `    ``while` `(next1 && curr2) {` `        ``// if curr2 lies in between curr1 and next1` `        ``// then do curr1->curr2->next1` `        ``if` `((curr2->data) >= (curr1->data) && (curr2->data) <= (next1->data)) {` `            ``next2 = curr2->next;` `            ``curr1->next = curr2;` `            ``curr2->next = next1;`   `            ``// now let curr1 and curr2 to point` `            ``// to their immediate next pointers` `            ``curr1 = curr2;` `            ``curr2 = next2;` `        ``}` `        ``else` `{` `            ``// if more nodes in first list` `            ``if` `(next1->next) {` `                ``next1 = next1->next;` `                ``curr1 = curr1->next;` `            ``}`   `            ``// else point the last node of first list` `            ``// to the remaining nodes of second list` `            ``else` `{` `                ``next1->next = curr2;` `                ``return` `h1;` `            ``}` `        ``}` `    ``}` `    ``return` `h1;` `}`   `// Merges two given lists in-place. This function` `// mainly compares head nodes and calls mergeUtil()` `struct` `Node* merge(``struct` `Node* h1,` `                   ``struct` `Node* h2)` `{` `    ``if` `(!h1)` `        ``return` `h2;` `    ``if` `(!h2)` `        ``return` `h1;`   `    ``// start with the linked list` `    ``// whose head data is the least` `    ``if` `(h1->data < h2->data)` `        ``return` `mergeUtil(h1, h2);` `    ``else` `        ``return` `mergeUtil(h2, h1);` `}`   `// Driver program` `int` `main()` `{` `    ``struct` `Node* head1 = newNode(1);` `    ``head1->next = newNode(3);` `    ``head1->next->next = newNode(5);`   `    ``// 1->3->5 LinkedList created`   `    ``struct` `Node* head2 = newNode(0);` `    ``head2->next = newNode(2);` `    ``head2->next->next = newNode(4);`   `    ``// 0->2->4 LinkedList created`   `    ``struct` `Node* mergedhead = merge(head1, head2);`   `    ``printList(mergedhead);` `    ``return` `0;` `}`

## Java

 `// Java program to merge two sorted` `// linked lists in-place.` `class` `GfG {`   `    ``static` `class` `Node {` `        ``int` `data;` `        ``Node next;` `    ``}`   `    ``// Function to create newNode in a linkedlist` `    ``static` `Node newNode(``int` `key)` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.data = key;` `        ``temp.next = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// A utility function to print linked list` `    ``static` `void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``System.out.print(node.data + ``" "``);` `            ``node = node.next;` `        ``}` `    ``}`   `    ``// Merges two lists with headers as h1 and h2.` `    ``// It assumes that h1's data is smaller than` `    ``// or equal to h2's data.` `    ``static` `Node mergeUtil(Node h1, Node h2)` `    ``{` `        ``// if only one node in first list` `        ``// simply point its head to second list` `        ``if` `(h1.next == ``null``) {` `            ``h1.next = h2;` `            ``return` `h1;` `        ``}`   `        ``// Initialize current and next pointers of` `        ``// both lists` `        ``Node curr1 = h1, next1 = h1.next;` `        ``Node curr2 = h2, next2 = h2.next;`   `        ``while` `(next1 != ``null` `&& curr2 != ``null``) {` `            ``// if curr2 lies in between curr1 and next1` `            ``// then do curr1->curr2->next1` `            ``if` `((curr2.data) >= (curr1.data) && (curr2.data) <= (next1.data)) {` `                ``next2 = curr2.next;` `                ``curr1.next = curr2;` `                ``curr2.next = next1;`   `                ``// now let curr1 and curr2 to point` `                ``// to their immediate next pointers` `                ``curr1 = curr2;` `                ``curr2 = next2;` `            ``}` `            ``else` `{` `                ``// if more nodes in first list` `                ``if` `(next1.next != ``null``) {` `                    ``next1 = next1.next;` `                    ``curr1 = curr1.next;` `                ``}`   `                ``// else point the last node of first list` `                ``// to the remaining nodes of second list` `                ``else` `{` `                    ``next1.next = curr2;` `                    ``return` `h1;` `                ``}` `            ``}` `        ``}` `        ``return` `h1;` `    ``}`   `    ``// Merges two given lists in-place. This function` `    ``// mainly compares head nodes and calls mergeUtil()` `    ``static` `Node merge(Node h1, Node h2)` `    ``{` `        ``if` `(h1 == ``null``)` `            ``return` `h2;` `        ``if` `(h2 == ``null``)` `            ``return` `h1;`   `        ``// start with the linked list` `        ``// whose head data is the least` `        ``if` `(h1.data < h2.data)` `            ``return` `mergeUtil(h1, h2);` `        ``else` `            ``return` `mergeUtil(h2, h1);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``Node head1 = newNode(``1``);` `        ``head1.next = newNode(``3``);` `        ``head1.next.next = newNode(``5``);`   `        ``// 1->3->5 LinkedList created`   `        ``Node head2 = newNode(``0``);` `        ``head2.next = newNode(``2``);` `        ``head2.next.next = newNode(``4``);`   `        ``// 0->2->4 LinkedList created`   `        ``Node mergedhead = merge(head1, head2);`   `        ``printList(mergedhead);` `    ``}` `}`   `// This code is contributed by` `// prerna saini`

## Python

 `# Python program to merge two sorted linked lists` `# in-place.`   `# Linked List node ` `class` `Node: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None`   `# Function to create newNode in a linkedlist` `def` `newNode(key):`   `    ``temp ``=` `Node(``0``)` `    ``temp.data ``=` `key` `    ``temp.``next` `=` `None` `    ``return` `temp`   `# A utility function to print linked list` `def` `printList(node):`   `    ``while` `(node !``=` `None``) :` `        ``print``( node.data, end ``=``" "``)` `        ``node ``=` `node.``next` `    `  `# Merges two lists with headers as h1 and h2.` `# It assumes that h1's data is smaller than` `# or equal to h2's data.` `def` `mergeUtil(h1, h2):`   `    ``# if only one node in first list` `    ``# simply point its head to second list` `    ``if` `(h1.``next` `=``=` `None``) :` `        ``h1.``next` `=` `h2` `        ``return` `h1` `    `  `    ``# Initialize current and next pointers of` `    ``# both lists` `    ``curr1 ``=` `h1` `    ``next1 ``=` `h1.``next` `    ``curr2 ``=` `h2` `    ``next2 ``=` `h2.``next`   `    ``while` `(next1 !``=` `None` `and` `curr2 !``=` `None``): ` `    `  `        ``# if curr2 lies in between curr1 and next1` `        ``# then do curr1.curr2.next1` `        ``if` `((curr2.data) >``=` `(curr1.data) ``and` `            ``(curr2.data) <``=` `(next1.data)) :` `            ``next2 ``=` `curr2.``next` `            ``curr1.``next` `=` `curr2` `            ``curr2.``next` `=` `next1`   `            ``# now let curr1 and curr2 to point` `            ``# to their immediate next pointers` `            ``curr1 ``=` `curr2` `            ``curr2 ``=` `next2` `        `  `        ``else` `:` `            ``# if more nodes in first list` `            ``if` `(next1.``next``) :` `                ``next1 ``=` `next1.``next` `                ``curr1 ``=` `curr1.``next` `            `  `            ``# else point the last node of first list` `            ``# to the remaining nodes of second list` `            ``else` `:` `                ``next1.``next` `=` `curr2` `                ``return` `h1`   `    ``return` `h1`   `# Merges two given lists in-place. This function` `# mainly compares head nodes and calls mergeUtil()` `def` `merge( h1, h2):`   `    ``if` `(h1 ``=``=` `None``):` `        ``return` `h2` `    ``if` `(h2 ``=``=` `None``):` `        ``return` `h1`   `    ``# start with the linked list` `    ``# whose head data is the least` `    ``if` `(h1.data < h2.data):` `        ``return` `mergeUtil(h1, h2)` `    ``else``:` `        ``return` `mergeUtil(h2, h1)`   `# Driver program`   `head1 ``=` `newNode(``1``)` `head1.``next` `=` `newNode(``3``)` `head1.``next``.``next` `=` `newNode(``5``)`   `# 1.3.5 LinkedList created`   `head2 ``=` `newNode(``0``)` `head2.``next` `=` `newNode(``2``)` `head2.``next``.``next` `=` `newNode(``4``)`   `# 0.2.4 LinkedList created`   `mergedhead ``=` `merge(head1, head2)`   `printList(mergedhead)`   `# This code is contributed by Arnab Kundu`

## C#

 `// C# program to merge two sorted` `// linked lists in-place.` `using` `System;`   `class` `GfG {`   `    ``public` `class` `Node {` `        ``public` `int` `data;` `        ``public` `Node next;` `    ``}`   `    ``// Function to create newNode in a linkedlist` `    ``static` `Node newNode(``int` `key)` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.data = key;` `        ``temp.next = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// A utility function to print linked list` `    ``static` `void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``Console.Write(node.data + ``" "``);` `            ``node = node.next;` `        ``}` `    ``}`   `    ``// Merges two lists with headers as h1 and h2.` `    ``// It assumes that h1's data is smaller than` `    ``// or equal to h2's data.` `    ``static` `Node mergeUtil(Node h1, Node h2)` `    ``{` `        ``// if only one node in first list` `        ``// simply point its head to second list` `        ``if` `(h1.next == ``null``) {` `            ``h1.next = h2;` `            ``return` `h1;` `        ``}`   `        ``// Initialize current and next pointers of` `        ``// both lists` `        ``Node curr1 = h1, next1 = h1.next;` `        ``Node curr2 = h2, next2 = h2.next;`   `        ``while` `(next1 != ``null` `&& curr2 != ``null``) {` `            ``// if curr2 lies in between curr1 and next1` `            ``// then do curr1->curr2->next1` `            ``if` `((curr2.data) >= (curr1.data)` `                ``&& (curr2.data) <= (next1.data)) {` `                ``next2 = curr2.next;` `                ``curr1.next = curr2;` `                ``curr2.next = next1;`   `                ``// now let curr1 and curr2 to point` `                ``// to their immediate next pointers` `                ``curr1 = curr2;` `                ``curr2 = next2;` `            ``}` `            ``else` `{` `                ``// if more nodes in first list` `                ``if` `(next1.next != ``null``) {` `                    ``next1 = next1.next;` `                    ``curr1 = curr1.next;` `                ``}`   `                ``// else point the last node of first list` `                ``// to the remaining nodes of second list` `                ``else` `{` `                    ``next1.next = curr2;` `                    ``return` `h1;` `                ``}` `            ``}` `        ``}` `        ``return` `h1;` `    ``}`   `    ``// Merges two given lists in-place. This function` `    ``// mainly compares head nodes and calls mergeUtil()` `    ``static` `Node merge(Node h1, Node h2)` `    ``{` `        ``if` `(h1 == ``null``)` `            ``return` `h2;` `        ``if` `(h2 == ``null``)` `            ``return` `h1;`   `        ``// start with the linked list` `        ``// whose head data is the least` `        ``if` `(h1.data < h2.data)` `            ``return` `mergeUtil(h1, h2);` `        ``else` `            ``return` `mergeUtil(h2, h1);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``Node head1 = newNode(1);` `        ``head1.next = newNode(3);` `        ``head1.next.next = newNode(5);`   `        ``// 1->3->5 LinkedList created`   `        ``Node head2 = newNode(0);` `        ``head2.next = newNode(2);` `        ``head2.next.next = newNode(4);`   `        ``// 0->2->4 LinkedList created`   `        ``Node mergedhead = merge(head1, head2);` `        ``printList(mergedhead);` `    ``}` `}`   `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``

Output:

`0 1 2 3 4 5 `

Complexity Analysis:

• Time complexity:O(n).
As only one traversal of the linked lists is needed.
• Auxiliary Space:O(1).
As there is no space required.

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