# Merge two sorted lists (in-place)

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

Output : 1->2->3->4->5->7
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

We have discussed different solutions in below post.

In this post, a new simpler solutions are discussed. The idea is to one by one compare nodes and form the result list.

Method 1 (Recursive)

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

Output:

```0 1 2 3 4 5
```

Method 2 (Iterative)

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

Output:

```0 1 2 3 4 5
```

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

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Article Tags :

9

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.