Union and Intersection of two Linked List using Merge Sort

Merge K sorted linked lists

Last Updated : 02 Jan, 2025

Given k sorted linked lists of different sizes, the task is to merge them all maintaining their sorted order.

Examples:

Input:

Output:

Merged lists in a sorted order where every element is greater than the previous element.
Input:

Output:

Merged lists in a sorted order where every element is greater than the previous element.

Table of Content

[Naive Approach - 1] - Merge One by One

The idea is to initialize the result as empty. Now one by one merge every linked list into the resultant list using the idea of merging two sorted linked lists. We always consider the result as first list and other list as second. At the end, we return result.

C++

// C++ program to merge K sorted linked lists
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int x) {
        data = x;
        next = nullptr;
    }
};

// Function to merge only 2 lists
Node* mergeTwo(Node* head1, Node* head2) {
    
    // Create a dummy node to simplify 
    // the merging process
    Node* dummy = new Node(-1);
    Node* curr = dummy;

    // Iterate through both linked lists
    while (head1 != nullptr && head2 != nullptr) {
      
        // Add the smaller node to the merged list
        if (head1->data <= head2->data) {
            curr->next = head1;
            head1 = head1->next;
        } else {
            curr->next = head2;
            head2 = head2->next;
        }
        curr = curr->next;
    }

    // If any list is left, append it to
    // the merged list
    if (head1 != nullptr) {
        curr->next = head1;
    } else {
        curr->next = head2;
    }

    // Return the merged list starting
    // from the next of dummy node
    return dummy->next;
}

// Function to merge K sorted linked lists
Node* mergeKLists(vector<Node*>& arr) {
  
    // Initialize result as empty
    Node *res = nullptr;
    
    // One by one merge all lists with 
    // res and keep updating res
    for (Node *node : arr) 
        res = mergeTwo(res, node);
        
    return res;
}

void printList(Node* node) {
    while (node != nullptr) {
        cout << node->data << " ";
        node = node->next;
    }
}

int main() {
    int k = 3; 
  
    vector<Node*> arr(k);

    arr[0] = new Node(1);
    arr[0]->next = new Node(3);
    arr[0]->next->next = new Node(5);
    arr[0]->next->next->next = new Node(7);

    arr[1] = new Node(2);
    arr[1]->next = new Node(4);
    arr[1]->next->next = new Node(6);
    arr[1]->next->next->next = new Node(8);

    arr[2] = new Node(0);
    arr[2]->next = new Node(9);
    arr[2]->next->next = new Node(10);
    arr[2]->next->next->next = new Node(11);
    
    Node* head = mergeKLists(arr);

    printList(head);

    return 0;
}

// C program to merge K sorted linked lists
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
};

struct Node* createNode(int data);

// Function to merge only 2 lists
struct Node* mergeTwo(struct Node* head1, struct Node* head2) {
    
    // Create a dummy node to simplify 
    // the merging process
    struct Node* dummy = createNode(-1);
    struct Node* curr = dummy;

    // Iterate through both linked lists
    while (head1 != NULL && head2 != NULL) {
      
        // Add the smaller node to the merged list
        if (head1->data <= head2->data) {
            curr->next = head1;
            head1 = head1->next;
        } else {
            curr->next = head2;
            head2 = head2->next;
        }
        curr = curr->next;
    }

    // If any list is left, append it to
    // the merged list
    if (head1 != NULL) {
        curr->next = head1;
    } else {
        curr->next = head2;
    }

    // Return the merged list starting
    // from the next of dummy node
    struct Node* merged = dummy->next;
    free(dummy);
    return merged;
}

// Function to merge K sorted linked lists
struct Node* mergeKLists(struct Node** arr, int k) {
  
    // Initialize result as empty
    struct Node* res = NULL;
    
    // One by one merge all lists with 
    // res and keep updating res
    for (int i = 0; i < k; i++) 
        res = mergeTwo(res, arr[i]);
        
    return res;
}

void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
}

struct Node* createNode(int data) {
    struct Node* newNode = 
    (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

int main() {
    int k = 3; 
    struct Node* arr[k];

    arr[0] = createNode(1);
    arr[0]->next = createNode(3);
    arr[0]->next->next = createNode(5);
    arr[0]->next->next->next = createNode(7);

    arr[1] = createNode(2);
    arr[1]->next = createNode(4);
    arr[1]->next->next = createNode(6);
    arr[1]->next->next->next = createNode(8);

    arr[2] = createNode(0);
    arr[2]->next = createNode(9);
    arr[2]->next->next = createNode(10);
    arr[2]->next->next->next = createNode(11);
    
    struct Node* head = mergeKLists(arr, k);

    printList(head);

    return 0;
}

Java

// Java program to merge K sorted linked lists
import java.util.List;
import java.util.ArrayList;

class Node {
    int data;
    Node next;

    Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {
    
    // Function to merge only 2 lists
    static Node mergeTwo(Node head1, Node head2) {
        
        // Create a dummy node to simplify 
        // the merging process
        Node dummy = new Node(-1);
        Node curr = dummy;

        // Iterate through both linked lists
        while (head1 != null && head2 != null) {
          
            // Add the smaller node to the merged list
            if (head1.data <= head2.data) {
                curr.next = head1;
                head1 = head1.next;
            } else {
                curr.next = head2;
                head2 = head2.next;
            }
            curr = curr.next;
        }

        // If any list is left, append it to
        // the merged list
        if (head1 != null) {
            curr.next = head1;
        } else {
            curr.next = head2;
        }

        // Return the merged list starting
        // from the next of dummy node
        return dummy.next;
    }

    // Function to merge K sorted linked lists
    static Node mergeKLists(List<Node> arr) {
      
        // Initialize result as empty
        Node res = null;
        
        // One by one merge all lists with 
        // res and keep updating res
        for (Node node : arr) 
            res = mergeTwo(res, node);
            
        return res;
    }

    static void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }

    public static void main(String[] args) {
        List<Node> arr = new ArrayList<>();

        arr.add(new Node(1));
        arr.get(0).next = new Node(3);
        arr.get(0).next.next = new Node(5);
        arr.get(0).next.next.next = new Node(7);

        arr.add(new Node(2));
        arr.get(1).next = new Node(4);
        arr.get(1).next.next = new Node(6);
        arr.get(1).next.next.next = new Node(8);

        arr.add(new Node(0));
        arr.get(2).next = new Node(9);
        arr.get(2).next.next = new Node(10);
        arr.get(2).next.next.next = new Node(11);

        Node head = mergeKLists(arr);

        printList(head);
    }
}

Python

# Python program to merge K sorted linked lists

class Node:
    def __init__(self, x):
        self.data = x
        self.next = None

# Function to merge only 2 lists
def mergeTwo(head1, head2):
    
    # Create a dummy node to simplify 
    # the merging process
    dummy = Node(-1)
    curr = dummy

    # Iterate through both linked lists
    while head1 is not None and head2 is not None:
      
        # Add the smaller node to the merged list
        if head1.data <= head2.data:
            curr.next = head1
            head1 = head1.next
        else:
            curr.next = head2
            head2 = head2.next
        curr = curr.next

    # If any list is left, append it to
    # the merged list
    if head1 is not None:
        curr.next = head1
    else:
        curr.next = head2

    # Return the merged list starting
    # from the next of dummy node
    return dummy.next

# Function to merge K sorted linked lists
def mergeKLists(arr):
    
    # Initialize result as empty
    res = None
    
    # One by one merge all lists with 
    # res and keep updating res
    for node in arr:
        res = mergeTwo(res, node)
        
    return res

def printList(node):
    while node is not None:
        print(node.data, end=" ")
        node = node.next

if __name__ == "__main__":
    arr = []

    node1 = Node(1)
    node1.next = Node(3)
    node1.next.next = Node(5)
    node1.next.next.next = Node(7)
    arr.append(node1)

    node2 = Node(2)
    node2.next = Node(4)
    node2.next.next = Node(6)
    node2.next.next.next = Node(8)
    arr.append(node2)

    node3 = Node(0)
    node3.next = Node(9)
    node3.next.next = Node(10)
    node3.next.next.next = Node(11)
    arr.append(node3)

    head = mergeKLists(arr)
    printList(head)

// C# program to merge K sorted linked lists
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node next;

    public Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {
    static Node mergeTwo(Node head1, Node head2) {
        
        // Create a dummy node to simplify 
        // the merging process
        Node dummy = new Node(-1);
        Node curr = dummy;

        // Iterate through both linked lists
        while (head1 != null && head2 != null) {
          
            // Add the smaller node to the merged list
            if (head1.data <= head2.data) {
                curr.next = head1;
                head1 = head1.next;
            } else {
                curr.next = head2;
                head2 = head2.next;
            }
            curr = curr.next;
        }

        // If any list is left, append it to
        // the merged list
        if (head1 != null) {
            curr.next = head1;
        } else {
            curr.next = head2;
        }

        // Return the merged list starting
        // from the next of dummy node
        return dummy.next;
    }

    static Node mergeKLists(List<Node> arr) {
        
        // Initialize result as empty
        Node res = null;
        
        // One by one merge all lists with 
        // res and keep updating res
        foreach (Node node in arr)
            res = mergeTwo(res, node);
            
        return res;
    }

    static void printList(Node node) {
        while (node != null) {
            Console.Write(node.data + " ");
            node = node.next;
        }
    }

    static void Main(string[] args) {
        List<Node> arr = new List<Node>();

        Node node1 = new Node(1);
        node1.next = new Node(3);
        node1.next.next = new Node(5);
        node1.next.next.next = new Node(7);
        arr.Add(node1);

        Node node2 = new Node(2);
        node2.next = new Node(4);
        node2.next.next = new Node(6);
        node2.next.next.next = new Node(8);
        arr.Add(node2);

        Node node3 = new Node(0);
        node3.next = new Node(9);
        node3.next.next = new Node(10);
        node3.next.next.next = new Node(11);
        arr.Add(node3);

        Node head = mergeKLists(arr);
        printList(head);
    }
}

JavaScript

// JavaScript program to merge K sorted linked lists

class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}

// Function to merge only 2 lists
function mergeTwo(head1, head2) {
    
    // Create a dummy node to simplify 
    // the merging process
    let dummy = new Node(-1);
    let curr = dummy;

    // Iterate through both linked lists
    while (head1 !== null && head2 !== null) {
      
        // Add the smaller node to the merged list
        if (head1.data <= head2.data) {
            curr.next = head1;
            head1 = head1.next;
        } else {
            curr.next = head2;
            head2 = head2.next;
        }
        curr = curr.next;
    }

    // If any list is left, append it to
    // the merged list
    if (head1 !== null) {
        curr.next = head1;
    } else {
        curr.next = head2;
    }

    // Return the merged list starting
    // from the next of dummy node
    return dummy.next;
}

// Function to merge K sorted linked lists
function mergeKLists(arr) {
    
    // Initialize result as empty
    let res = null;
    
    // One by one merge all lists with 
    // res and keep updating res
    for (let node of arr) 
        res = mergeTwo(res, node);
        
    return res;
}

function printList(node) {
    while (node !== null) {
        console.log(node.data + " ");
        node = node.next;
    }
}

let arr = [];

let node1 = new Node(1);
node1.next = new Node(3);
node1.next.next = new Node(5);
node1.next.next.next = new Node(7);
arr.push(node1);

let node2 = new Node(2);
node2.next = new Node(4);
node2.next.next = new Node(6);
node2.next.next.next = new Node(8);
arr.push(node2);

let node3 = new Node(0);
node3.next = new Node(9);
node3.next.next = new Node(10);
node3.next.next.next = new Node(11);
arr.push(node3);

let head = mergeKLists(arr);
printList(head);

Output

0 1 2 3 4 5 6 7 8 9 10 11

Time complexity: O(n*k*k), For simplicity, let us assume that every list is of equal size n. In the worst case. we take n + 2n + 3n ..... + k * n time. The sum of this series is n * k * (k + 1) / 2 which is O(n * k * k).
Auxiliary Space: O(1).

[Naive Approach - 2] - Repeatedly Select Min of All Remaining

The idea is to iterate through all the k head nodes and append the head node with minimum value to the resultant list. Increment the head to next node. Repeat this process until all nodes are processed.

Step by step approach:

Initialize a dummy head for the resultant list.
Find the node with the smallest value in all the k lists.
Increment the current pointer to the next node of the list where the smallest node is found.
Append the node with smallest value to the resultant list.
Repeat these steps till all nodes have been used.

C++

// C++ program to merge K sorted linked lists
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int x) {
        data = x;
        next = nullptr;
    }
};

// Function to get node with minimum value
Node* getMinNode(vector<Node*> &arr) {
    
    Node* mini = nullptr;
    int index = -1;
    
    for (int i=0; i<arr.size(); i++) {
        
        // If current list is processed
        if (arr[i]==nullptr) continue;
        
        // If min node is not set or 
        // current head has smaller value.
        if (mini==nullptr || arr[i]->data<mini->data) {
            index = i;
            mini = arr[i];
        }
    }
    
    // Increment the head node 
    if (index!=-1) arr[index] = arr[index]->next;
    
    return mini;
}

// Function to merge K sorted linked lists
Node* mergeKLists(vector<Node*>& arr) {
  
    // Create a dummy node to simplify 
    // the merging process
    Node* dummy = new Node(-1);
    Node* tail = dummy;
    
    Node* mini = getMinNode(arr);
    
    // Process all nodes.
    while (mini != nullptr) {
        
        // Append min node to the result.
        tail->next = mini;
        tail = mini;
        
        // Find the next min node 
        mini = getMinNode(arr);
    }

    // Return the merged list starting
    // from the next of dummy node
    return dummy->next;
}

void printList(Node* node) {
    while (node != nullptr) {
        cout << node->data << " ";
        node = node->next;
    }
}

int main() {
    int k = 3; 
  
    vector<Node*> arr(k);

    arr[0] = new Node(1);
    arr[0]->next = new Node(3);
    arr[0]->next->next = new Node(5);
    arr[0]->next->next->next = new Node(7);

    arr[1] = new Node(2);
    arr[1]->next = new Node(4);
    arr[1]->next->next = new Node(6);
    arr[1]->next->next->next = new Node(8);

    arr[2] = new Node(0);
    arr[2]->next = new Node(9);
    arr[2]->next->next = new Node(10);
    arr[2]->next->next->next = new Node(11);
    
    Node* head = mergeKLists(arr);

    printList(head);

    return 0;
}

Java

// Java program to merge K sorted linked lists
import java.util.*;

class Node {
    int data;
    Node next;

    Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {
    
    // Function to get node with minimum value
    static Node getMinNode(List<Node> arr) {
        Node mini = null;
        int index = -1;
        
        for (int i = 0; i < arr.size(); i++) {
            
            // If current list is processed
            if (arr.get(i) == null) continue;
            
            // If min node is not set or 
            // current head has smaller value.
            if (mini == null || arr.get(i).data < mini.data) {
                index = i;
                mini = arr.get(i);
            }
        }
        
        // Increment the head node 
        if (index != -1) arr.set(index, arr.get(index).next);
        
        return mini;
    }
    
    // Function to merge K sorted linked lists
    static Node mergeKLists(List<Node> arr) {
        Node dummy = new Node(-1);
        Node tail = dummy;
    
        Node mini = getMinNode(arr);
        
        // Process all nodes.
        while (mini != null) {
            
            // Append min node to the result.
            tail.next = mini;
            tail = mini;
            
            // Find the next min node 
            mini = getMinNode(arr);
        }
    
        return dummy.next;
    }
    
    static void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }
    
    public static void main(String[] args) {
        List<Node> arr = new ArrayList<>();
        arr.add(new Node(1));
        arr.get(0).next = new Node(3);
        arr.get(0).next.next = new Node(5);
        arr.get(0).next.next.next = new Node(7);
    
        arr.add(new Node(2));
        arr.get(1).next = new Node(4);
        arr.get(1).next.next = new Node(6);
        arr.get(1).next.next.next = new Node(8);
    
        arr.add(new Node(0));
        arr.get(2).next = new Node(9);
        arr.get(2).next.next = new Node(10);
        arr.get(2).next.next.next = new Node(11);
    
        Node head = mergeKLists(arr);
        printList(head);
    }
}

Python

# Python program to merge K sorted linked lists

class Node:
    def __init__(self, x):
        self.data = x
        self.next = None

# Function to get node with minimum value
def getMinNode(arr):
    mini = None
    index = -1

    for i in range(len(arr)):
      
        # If current list is processed
        if arr[i] is None:
            continue

        # If min node is not set or 
        # current head has smaller value.
        if mini is None or arr[i].data < mini.data:
            index = i
            mini = arr[i]

    # Increment the head node
    if index != -1:
        arr[index] = arr[index].next

    return mini

# Function to merge K sorted linked lists
def mergeKLists(arr):
    dummy = Node(-1)
    tail = dummy

    mini = getMinNode(arr)

    # Process all nodes.
    while mini:
        
        # Append min node to the result.
        tail.next = mini
        tail = mini

        # Find the next min node
        mini = getMinNode(arr)

    return dummy.next

def printList(node):
    while node:
        print(node.data, end=" ")
        node = node.next

if __name__ == "__main__":
    arr = [None] * 3

    arr[0] = Node(1)
    arr[0].next = Node(3)
    arr[0].next.next = Node(5)
    arr[0].next.next.next = Node(7)

    arr[1] = Node(2)
    arr[1].next = Node(4)
    arr[1].next.next = Node(6)
    arr[1].next.next.next = Node(8)

    arr[2] = Node(0)
    arr[2].next = Node(9)
    arr[2].next.next = Node(10)
    arr[2].next.next.next = Node(11)

    head = mergeKLists(arr)
    printList(head)

// C# program to merge K sorted linked lists
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node next;

    public Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {
    
    // Function to get node with minimum value
    static Node getMinNode(List<Node> arr) {
        Node mini = null;
        int index = -1;

        for (int i = 0; i < arr.Count; i++) {
            // If current list is processed
            if (arr[i] == null) continue;

            // If min node is not set or 
            // current head has smaller value.
            if (mini == null || arr[i].data < mini.data) {
                index = i;
                mini = arr[i];
            }
        }

        // Increment the head node
        if (index != -1) arr[index] = arr[index].next;

        return mini;
    }

    // Function to merge K sorted linked lists
    static Node mergeKLists(List<Node> arr) {
        Node dummy = new Node(-1);
        Node tail = dummy;

        Node mini = getMinNode(arr);

        // Process all nodes.
        while (mini != null) {
            
            // Append min node to the result.
            tail.next = mini;
            tail = mini;

            // Find the next min node
            mini = getMinNode(arr);
        }

        return dummy.next;
    }

    static void printList(Node node) {
        while (node != null) {
            Console.Write(node.data + " ");
            node = node.next;
        }
    }

    static void Main() {
        List<Node> arr = new List<Node>();

        arr.Add(new Node(1));
        arr[0].next = new Node(3);
        arr[0].next.next = new Node(5);
        arr[0].next.next.next = new Node(7);

        arr.Add(new Node(2));
        arr[1].next = new Node(4);
        arr[1].next.next = new Node(6);
        arr[1].next.next.next = new Node(8);

        arr.Add(new Node(0));
        arr[2].next = new Node(9);
        arr[2].next.next = new Node(10);
        arr[2].next.next.next = new Node(11);

        Node head = mergeKLists(arr);
        printList(head);
    }
}

JavaScript

// JavaScript program to merge K sorted linked lists

class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}

// Function to get node with minimum value
function getMinNode(arr) {
    let mini = null;
    let index = -1;

    for (let i = 0; i < arr.length; i++) {
        
        // If current list is processed
        if (arr[i] === null) continue;

        // If min node is not set or 
        // current head has smaller value.
        if (mini === null || arr[i].data < mini.data) {
            index = i;
            mini = arr[i];
        }
    }

    // Increment the head node
    if (index !== -1) arr[index] = arr[index].next;

    return mini;
}

// Function to merge K sorted linked lists
function mergeKLists(arr) {
    let dummy = new Node(-1);
    let tail = dummy;

    let mini = getMinNode(arr);

    // Process all nodes.
    while (mini !== null) {
        
        // Append min node to the result.
        tail.next = mini;
        tail = mini;

        // Find the next min node
        mini = getMinNode(arr);
    }

    return dummy.next;
}

function printList(node) {
    while (node !== null) {
        console.log(node.data + " ");
        node = node.next;
    }
}

let arr = [];

arr.push(new Node(1));
arr[0].next = new Node(3);
arr[0].next.next = new Node(5);
arr[0].next.next.next = new Node(7);

arr.push(new Node(2));
arr[1].next = new Node(4);
arr[1].next.next = new Node(6);
arr[1].next.next.next = new Node(8);

arr.push(new Node(0));
arr[2].next = new Node(9);
arr[2].next.next = new Node(10);
arr[2].next.next.next = new Node(11);

let head = mergeKLists(arr);
printList(head);

Output

0 1 2 3 4 5 6 7 8 9 10 11

Time complexity: O(n * k²), There are n*k nodes in total (assuming every list has O(n) nodes) and to find the smallest node it takes k times so for the n*k nodes it will take n*k*k time.
Auxiliary Space: O(1)

[Expected Approach - 1] - Using Min Heap (Works better for unequal sized lists)

This solution is mainly an optimization over the previous approach. Instead of linearly traversing the array to find the minimum, we use min heap data structure and reduce the time complexity of this operation to O(Log k).

For a more detailed solution and code, refer to article Merge k sorted linked lists Using Min Heap.

Time Complexity: O(n * k * log k) if we have k lists of size O(n) each. We can also say O(n * Log k) where n is the total number of nodes.
Auxiliary Space: O(k)

[Expected Approach - 2] - Using Divide and Conquer (Works better for equal sized lists)

The idea is to use divide and conquer by recursively splitting the k lists into two halves until we have pairs of lists to merge, then merge these pairs using a two-way merge procedure (similar to merge sort's merge step), and continue this process back up through the recursion tree until all lists are merged into a single sorted list.

Step by step approach:

Split k lists into two parts: lists[0...mid] and lists[mid+1...end].
Recursively merge the left half of lists to get first sorted list.
Recursively merge the right half of lists to get second sorted list.
Merge the above two sorted lists using two-pointer approach.
Return the final merged sorted list.

C++

// C++ program to merge K sorted linked lists
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node(int x) {
        data = x;
        next = nullptr;
    }
};

// Function to merge two sorted lists.
Node* mergeTwo(Node* head1, Node* head2) {
  
    // Create a dummy node to simplify 
    // the merging process
    Node* dummy = new Node(-1);
    Node* curr = dummy;

    // Iterate through both linked lists
    while (head1 != nullptr && head2 != nullptr) {
      
        // Add the smaller node to the merged list
        if (head1->data <= head2->data) {
            curr->next = head1;
            head1 = head1->next;
        } else {
            curr->next = head2;
            head2 = head2->next;
        }
        curr = curr->next;
    }

    // If any list is left, append it to
    // the merged list
    if (head1 != nullptr) {
        curr->next = head1;
    } else {
        curr->next = head2;
    }

    // Return the merged list starting
    // from the next of dummy node
    return dummy->next;
}

Node* mergeListsRecur(int i, int j, vector<Node*> &arr) {
    
    // If single list is left
    if (i == j) return arr[i];
    
    // Find the middle of lists
    int mid = i + (j-i)/2;
    
    // Merge lists from i to mid 
    Node* head1 = mergeListsRecur(i, mid, arr);
    
    // Merge lists from mid+1 to j 
    Node* head2 = mergeListsRecur(mid+1, j, arr);
    
    // Merge the above 2 lists 
    Node* head = mergeTwo(head1, head2);
    
    return head;
}

// Function to merge K sorted linked lists
Node* mergeKLists(vector<Node*>& arr) {
    
    // Base case for 0 lists 
    if (arr.size()==0) return nullptr;
  
    return mergeListsRecur(0, arr.size()-1, arr);
}

void printList(Node* node) {
    while (node != nullptr) {
        cout << node->data << " ";
        node = node->next;
    }
}

int main() {
    int k = 3; 
  
    vector<Node*> arr(k);

    arr[0] = new Node(1);
    arr[0]->next = new Node(3);
    arr[0]->next->next = new Node(5);
    arr[0]->next->next->next = new Node(7);

    arr[1] = new Node(2);
    arr[1]->next = new Node(4);
    arr[1]->next->next = new Node(6);
    arr[1]->next->next->next = new Node(8);

    arr[2] = new Node(0);
    arr[2]->next = new Node(9);
    arr[2]->next->next = new Node(10);
    arr[2]->next->next->next = new Node(11);
    
    Node* head = mergeKLists(arr);

    printList(head);

    return 0;
}

Java

// Java program to merge K sorted linked lists
import java.util.List;

class Node {
    int data;
    Node next;

    Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // Function to merge two sorted lists.
    static Node mergeTwo(Node head1, Node head2) {

        // Create a dummy node to simplify 
        // the merging process
        Node dummy = new Node(-1);
        Node curr = dummy;

        // Iterate through both linked lists
        while (head1 != null && head2 != null) {

            // Add the smaller node to the merged list
            if (head1.data <= head2.data) {
                curr.next = head1;
                head1 = head1.next;
            } else {
                curr.next = head2;
                head2 = head2.next;
            }
            curr = curr.next;
        }

        // If any list is left, append it to
        // the merged list
        if (head1 != null) {
            curr.next = head1;
        } else {
            curr.next = head2;
        }

        // Return the merged list starting
        // from the next of dummy node
        return dummy.next;
    }

    static Node mergeListsRecur(int i, int j, List<Node> arr) {

        // If single list is left
        if (i == j) return arr.get(i);

        // Find the middle of lists
        int mid = i + (j - i) / 2;

        // Merge lists from i to mid 
        Node head1 = mergeListsRecur(i, mid, arr);

        // Merge lists from mid+1 to j 
        Node head2 = mergeListsRecur(mid + 1, j, arr);

        // Merge the above 2 lists 
        Node head = mergeTwo(head1, head2);

        return head;
    }

    // Function to merge K sorted linked lists
    static Node mergeKLists(List<Node> arr) {

        // Base case for 0 lists 
        if (arr.size() == 0) return null;

        return mergeListsRecur(0, arr.size() - 1, arr);
    }

    static void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }

    public static void main(String[] args) {
        int k = 3;

        List<Node> arr = new java.util.ArrayList<>();

        arr.add(new Node(1));
        arr.get(0).next = new Node(3);
        arr.get(0).next.next = new Node(5);
        arr.get(0).next.next.next = new Node(7);

        arr.add(new Node(2));
        arr.get(1).next = new Node(4);
        arr.get(1).next.next = new Node(6);
        arr.get(1).next.next.next = new Node(8);

        arr.add(new Node(0));
        arr.get(2).next = new Node(9);
        arr.get(2).next.next = new Node(10);
        arr.get(2).next.next.next = new Node(11);

        Node head = mergeKLists(arr);

        printList(head);
    }
}

Python

# Python program to merge K sorted linked lists

class Node:
    def __init__(self, x):
        self.data = x
        self.next = None

# Function to merge two sorted lists.
def mergeTwo(head1, head2):
    
    # Create a dummy node to simplify 
    # the merging process
    dummy = Node(-1)
    curr = dummy

    # Iterate through both linked lists
    while head1 is not None and head2 is not None:
      
        # Add the smaller node to the merged list
        if head1.data <= head2.data:
            curr.next = head1
            head1 = head1.next
        else:
            curr.next = head2
            head2 = head2.next
        curr = curr.next

    # If any list is left, append it to
    # the merged list
    if head1 is not None:
        curr.next = head1
    else:
        curr.next = head2

    # Return the merged list starting
    # from the next of dummy node
    return dummy.next

def mergeListsRecur(i, j, arr):
    
    # If single list is left
    if i == j:
        return arr[i]

    # Find the middle of lists
    mid = i + (j - i) // 2

    # Merge lists from i to mid 
    head1 = mergeListsRecur(i, mid, arr)

    # Merge lists from mid+1 to j 
    head2 = mergeListsRecur(mid + 1, j, arr)

    # Merge the above 2 lists 
    head = mergeTwo(head1, head2)

    return head

# Function to merge K sorted linked lists
def mergeKLists(arr):
    
    # Base case for 0 lists 
    if len(arr) == 0:
        return None

    return mergeListsRecur(0, len(arr) - 1, arr)

def printList(node):
    while node is not None:
        print(node.data, end=" ")
        node = node.next

if __name__ == "__main__":
    k = 3

    arr = [None] * k

    arr[0] = Node(1)
    arr[0].next = Node(3)
    arr[0].next.next = Node(5)
    arr[0].next.next.next = Node(7)

    arr[1] = Node(2)
    arr[1].next = Node(4)
    arr[1].next.next = Node(6)
    arr[1].next.next.next = Node(8)

    arr[2] = Node(0)
    arr[2].next = Node(9)
    arr[2].next.next = Node(10)
    arr[2].next.next.next = Node(11)

    head = mergeKLists(arr)

    printList(head)

// C# program to merge K sorted linked lists
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node next;

    public Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // Function to merge two sorted lists.
    static Node mergeTwo(Node head1, Node head2) {

        // Create a dummy node to simplify 
        // the merging process
        Node dummy = new Node(-1);
        Node curr = dummy;

        // Iterate through both linked lists
        while (head1 != null && head2 != null) {

            // Add the smaller node to the merged list
            if (head1.data <= head2.data) {
                curr.next = head1;
                head1 = head1.next;
            } else {
                curr.next = head2;
                head2 = head2.next;
            }
            curr = curr.next;
        }

        // If any list is left, append it to
        // the merged list
        if (head1 != null) {
            curr.next = head1;
        } else {
            curr.next = head2;
        }

        // Return the merged list starting
        // from the next of dummy node
        return dummy.next;
    }

    static Node mergeListsRecur(int i, int j, List<Node> arr) {

        // If single list is left
        if (i == j) return arr[i];

        // Find the middle of lists
        int mid = i + (j - i) / 2;

        // Merge lists from i to mid 
        Node head1 = mergeListsRecur(i, mid, arr);

        // Merge lists from mid+1 to j 
        Node head2 = mergeListsRecur(mid + 1, j, arr);

        // Merge the above 2 lists 
        Node head = mergeTwo(head1, head2);

        return head;
    }

    // Function to merge K sorted linked lists
    static Node mergeKLists(List<Node> arr) {

        // Base case for 0 lists 
        if (arr.Count == 0) return null;

        return mergeListsRecur(0, arr.Count - 1, arr);
    }

    static void printList(Node node) {
        while (node != null) {
            Console.Write(node.data + " ");
            node = node.next;
        }
    }

    static void Main(string[] args) {

        List<Node> arr = new List<Node>();

        arr.Add(new Node(1));
        arr[0].next = new Node(3);
        arr[0].next.next = new Node(5);
        arr[0].next.next.next = new Node(7);

        arr.Add(new Node(2));
        arr[1].next = new Node(4);
        arr[1].next.next = new Node(6);
        arr[1].next.next.next = new Node(8);

        arr.Add(new Node(0));
        arr[2].next = new Node(9);
        arr[2].next.next = new Node(10);
        arr[2].next.next.next = new Node(11);

        Node head = mergeKLists(arr);

        printList(head);
    }
}

JavaScript

// JavaScript program to merge K sorted linked lists

class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}

// Function to merge two sorted lists.
function mergeTwo(head1, head2) {

    // Create a dummy node to simplify 
    // the merging process
    let dummy = new Node(-1);
    let curr = dummy;

    // Iterate through both linked lists
    while (head1 !== null && head2 !== null) {

        // Add the smaller node to the merged list
        if (head1.data <= head2.data) {
            curr.next = head1;
            head1 = head1.next;
        } else {
            curr.next = head2;
            head2 = head2.next;
        }
        curr = curr.next;
    }

    // If any list is left, append it to
    // the merged list
    if (head1 !== null) {
        curr.next = head1;
    } else {
        curr.next = head2;
    }

    // Return the merged list starting
    // from the next of dummy node
    return dummy.next;
}

function mergeListsRecur(i, j, arr) {

    // If single list is left
    if (i === j) return arr[i];

    // Find the middle of lists
    let mid = i + Math.floor((j - i) / 2);

    // Merge lists from i to mid 
    let head1 = mergeListsRecur(i, mid, arr);

    // Merge lists from mid+1 to j 
    let head2 = mergeListsRecur(mid + 1, j, arr);

    // Merge the above 2 lists 
    return mergeTwo(head1, head2);
}

// Function to merge K sorted linked lists
function mergeKLists(arr) {

    // Base case for 0 lists 
    if (arr.length === 0) return null;

    return mergeListsRecur(0, arr.length - 1, arr);
}

function printList(node) {
    while (node !== null) {
        console.log(node.data + " ");
        node = node.next;
    }
}

let k = 3;

let arr = [];

arr[0] = new Node(1);
arr[0].next = new Node(3);
arr[0].next.next = new Node(5);
arr[0].next.next.next = new Node(7);

arr[1] = new Node(2);
arr[1].next = new Node(4);
arr[1].next.next = new Node(6);
arr[1].next.next.next = new Node(8);

arr[2] = new Node(0);
arr[2].next = new Node(9);
arr[2].next.next = new Node(10);
arr[2].next.next.next = new Node(11);

let head = mergeKLists(arr);

printList(head);

Output

0 1 2 3 4 5 6 7 8 9 10 11

Time Complexity: O(n * k * log k), where n is the number of nodes in the longest list.
Auxiliary Space: O(log k), used for recursion.

Union and Intersection of two Linked List using Merge Sort

kartik

Improve

Article Tags :

Practice Tags :

Merge K sorted linked lists

[Naive Approach - 1] - Merge One by One

[Naive Approach - 2] - Repeatedly Select Min of All Remaining

[Expected Approach - 1] - Using Min Heap (Works better for unequal sized lists)

[Expected Approach - 2] - Using Divide and Conquer (Works better for equal sized lists)

Similar Reads

Merge sort in different languages

Variations of Merge Sort

Merge Sort in Linked List

Visualization of Merge Sort

Some problems on Merge Sort

Thank You!

What kind of Experience do you want to share?