Merge two sorted lists (in-place)

Last Updated : 21 Apr, 2024

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

Examples:

`Input : head1: 5->7->9        head2: 4->6->8 Output : 4->5->6->7->8->9Explanation: The output list is in sorted order.Input : head1: 1->3->5->7        head2: 2->4Output : 1->2->3->4->5->7Explanation: 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.

Implementation:

C++ ```// C++ program to merge two sorted linked lists // in-place. #include <bits/stdc++.h> 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) { cout << 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; 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; } // This code is contributed by Aditya Kumar (adityakumar129) // Improved by kislay__kumar ``` C ```#include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; struct Node* newNode(int key) { struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); temp->data = key; temp->next = NULL; return temp; } void printList(struct Node* node) { while (node != NULL) { printf("%d ", node->data); node = node->next; } } struct Node* merge(struct Node* h1, struct Node* h2) { if (!h1) return h2; if (!h2) return h1; if (h1->data <= h2->data) { h1->next = merge(h1->next, h2); return h1; } else { h2->next = merge(h1, h2->next); return h2; } } int main() { struct Node* head1 = newNode(1); head1->next = newNode(3); head1->next->next = newNode(5); struct Node* head2 = newNode(0); head2->next = newNode(2); head2->next->next = newNode(4); struct Node* mergedhead = merge(head1, head2); printList(mergedhead); return 0; } ``` Java ```class Node { int data; Node next; Node(int key) { data = key; next = null; } } public class Main { static Node merge(Node h1, Node h2) { if (h1 == null) return h2; if (h2 == null) return h1; if (h1.data <= h2.data) { h1.next = merge(h1.next, h2); return h1; } else { h2.next = merge(h1, h2.next); return h2; } } static void printList(Node node) { while (node != null) { System.out.print(node.data + " "); node = node.next; } } public static void main(String[] args) { Node head1 = new Node(1); head1.next = new Node(3); head1.next.next = new Node(5); Node head2 = new Node(0); head2.next = new Node(2); head2.next.next = new Node(4); Node mergedhead = merge(head1, head2); printList(mergedhead); } } ``` Python3 ```class Node: def __init__(self, key): self.data = key self.next = None def merge(h1, h2): if not h1: return h2 if not h2: return h1 if h1.data <= h2.data: h1.next = merge(h1.next, h2) return h1 else: h2.next = merge(h1, h2.next) return h2 def printList(node): while node: print(node.data, end=" ") node = node.next head1 = Node(1) head1.next = Node(3) head1.next.next = Node(5) head2 = Node(0) head2.next = Node(2) head2.next.next = Node(4) mergedhead = merge(head1, head2) printList(mergedhead) ``` C# ```using System; public class Node { public int data; public Node next; public Node(int key) { data = key; next = null; } } public class Program { static Node Merge(Node h1, Node h2) { if (h1 == null) return h2; if (h2 == null) return h1; if (h1.data <= h2.data) { h1.next = Merge(h1.next, h2); return h1; } else { h2.next = Merge(h1, h2.next); return h2; } } static void PrintList(Node node) { while (node != null) { Console.Write(node.data + " "); node = node.next; } } public static void Main(string[] args) { Node head1 = new Node(1); head1.next = new Node(3); head1.next.next = new Node(5); Node head2 = new Node(0); head2.next = new Node(2); head2.next.next = new Node(4); Node mergedhead = Merge(head1, head2); PrintList(mergedhead); } } ``` Javascript ```class Node { constructor(key) { this.data = key; this.next = null; } } function merge(h1, h2) { if (!h1) return h2; if (!h2) return h1; if (h1.data <= h2.data) { h1.next = merge(h1.next, h2); return h1; } else { h2.next = merge(h1, h2.next); return h2; } } function printList(node) { while (node) { console.log(node.data + " "); node = node.next; } } let head1 = new Node(1); head1.next = new Node(3); head1.next.next = new Node(5); let head2 = new Node(0); head2.next = new Node(2); head2.next.next = new Node(4); let mergedhead = merge(head1, head2); printList(mergedhead); ```

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.

Implementation:

C++ ```// C++ program to merge two sorted linked lists // in-place. #include <bits/stdc++.h> 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; } // This code is contributed by Aditya Kumar (adityakumar129) ``` C ```// C program to merge two sorted linked lists // in-place. #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node* next; } Node; // Function to create newNode in a linkedlist Node* newNode(int key) { Node* temp = (Node *)malloc(sizeof(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 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(Node* h1, 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 Node *curr1 = h1, *next1 = h1->next; 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() 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) return mergeUtil(h1, h2); else return mergeUtil(h2, h1); } // 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; } // This code is contributed by Aditya Kumar (adityakumar129) ``` 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 ```<script> // JavaScript program to merge two sorted // linked lists in-place. class Node { constructor() { this.data = 0; this.next = null; } } // Function to create newNode in a linkedlist function newNode(key) { var temp = new Node(); temp.data = key; temp.next = null; return temp; } // A utility function to print linked list function printList(node) { while (node != null) { document.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. function mergeUtil(h1, 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 var curr1 = h1, next1 = h1.next; var 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() function merge(h1, 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 var head1 = newNode(1); head1.next = newNode(3); head1.next.next = newNode(5); // 1->3->5 LinkedList created var head2 = newNode(0); head2.next = newNode(2); head2.next.next = newNode(4); // 0->2->4 LinkedList created var mergedhead = merge(head1, head2); printList(mergedhead); // This code contributed by gauravrajput1 </script> ```

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.

Previous
Next