Merge two sorted lists (in-place)

24 Jun, 2022
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->9
Explanation: The output list is in sorted order.

Input : head1: 1->3->5->7
        head2: 2->4
Output : 1->2->3->4->5->7
Explanation: The output list is in sorted order.
 
There are different discussed different solutions in post below. Merge two sorted linked lists 
Method 1 (Recursive)
Approach: The recursive solution can be formed, given the linked lists are sorted.  
Compare the head of both linked lists.Find the smaller node among the two head nodes. The current element will be the smaller node among two head nodes.The rest elements of both lists will appear after that.Now run a recursive function with parameters, the next node of the smaller element, and the other head.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()Handle some corner cases. If both the heads are NULL return null.If one head is null return the other.
Compare the head of both linked lists.
Find the smaller node among the two head nodes. The current element will be the smaller node among two head nodes.
The rest elements of both lists will appear after that.
Now run a recursive function with parameters, the next node of the smaller element, and the other head.
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()
Handle some corner cases. If both the heads are NULL return null.If one head is null return the other.
If both the heads are NULL return null.
If one head is null return the other.
 
C++
C
Java
Python3
C#
Javascript
// 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 linkedlistNode* newNode(int key){    struct Node* temp = new Node;    temp->data = key;    temp->next = NULL;    return temp;}  // A utility function to print linked listvoid 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;      // 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 programint 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)
// 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 linkedlistNode* newNode(int key){    struct Node* temp = (Node*)malloc(sizeof(Node));    temp->data = key;    temp->next = NULL;    return temp;}  // A utility function to print linked listvoid 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 programint 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 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 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 linkedlistdef newNode( key):    temp = Node(key)    temp.data = key    temp.next = None    return temp  # A utility function to print linked listdef 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 Codeif __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# 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
<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) {         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 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) {            h1.next = merge(h1.next, h2);            return h1;        } else {            h2.next = merge(h1, h2.next);            return h2;        }    }      // 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 contributed by umadevi9616</script>
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. 
Traverse the list from start to end.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.If the first list has reached end while traversing, point the next node to the head of second list.
Traverse the list from start to end.
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.
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
Java
Python
C#
Javascript
// 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 linkedliststruct Node* newNode(int key){    struct Node* temp = new Node;    temp->data = key;    temp->next = NULL;    return temp;}  // A utility function to print linked listvoid 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 programint 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 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 linkedlistNode* newNode(int key){    Node* temp = (Node *)malloc(sizeof(Node));    temp->data = key;    temp->next = NULL;    return temp;}  // A utility function to print linked listvoid 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 programint 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 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 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 linkedlistdef newNode(key):      temp = Node(0)    temp.data = key    temp.next = None    return temp  # A utility function to print linked listdef 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# 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 */
<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.
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 review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
prerna saini
princiraj1992
andrew1234
29AjayKumar
mrityunjoy
gp6
sapnasingh4991
umadevi9616
GauravRajput1
arorakashish0911
adityakumar129
Accolite
Amazon
Belzabar
Brocade
FactSet
Flipkart
MakeMyTrip
Microsoft
OATS Systems
Oracle
Samsung
Synopsys
Linked List
Flipkart
Accolite
Amazon
Microsoft
Samsung
FactSet
MakeMyTrip
Oracle
Brocade
Synopsys
OATS Systems
Belzabar
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.