# Merge k sorted linked lists | Set 2 (Using Min Heap)

Given k sorted linked lists each of size n, merge them and print the sorted output.

Examples:

```Input: k = 3, n =  4
list1 = 1->3->5->7->NULL
list2 = 2->4->6->8->NULL
list3 = 0->9->10->11

Output:
0->1->2->3->4->5->6->7->8->9->10->11
```

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

Approach: An efficient solution for the problem has been dicussed in Method 3 of this post. Here another solution has been provided which the uses the MIN HEAP data structure. This solution is based on the min heap approach used to solve the problem ‘merge k sorted arrays’ which is discussed here.

## C++

 `// C++ implementation to merge k sorted linked lists ` `// | Using MIN HEAP method ` `#include ` `using` `namespace` `std; ` ` `  `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` ` `  `// 'compare' function used to build up the ` `// priority queue ` `struct` `compare { ` `    ``bool` `operator()(``struct` `Node* a, ``struct` `Node* b) ` `    ``{ ` `        ``return` `a->data > b->data; ` `    ``} ` `}; ` ` `  `// function to merge k sorted linked lists ` `struct` `Node* mergeKSortedLists(``struct` `Node* arr[], ``int` `k) ` `{ ` `    ``struct` `Node *head = NULL, *last; ` ` `  `    ``// priority_queue 'pq' implemeted as min heap with the ` `    ``// help of 'compare' function ` `    ``priority_queue, compare> pq; ` ` `  `    ``// push the head nodes of all the k lists in 'pq' ` `    ``for` `(``int` `i = 0; i < k; i++) ` `        ``if` `(arr[i] != NULL) ` `            ``pq.push(arr[i]); ` ` `  `    ``// loop till 'pq' is not empty ` `    ``while` `(!pq.empty()) { ` ` `  `        ``// get the top element of 'pq' ` `        ``struct` `Node* top = pq.top(); ` `        ``pq.pop(); ` ` `  `        ``// check if there is a node next to the 'top' node ` `        ``// in the list of which 'top' node is a member ` `        ``if` `(top->next != NULL) ` `            ``// push the next node in 'pq' ` `            ``pq.push(top->next); ` ` `  `        ``// if final merged list is empty ` `        ``if` `(head == NULL) { ` `            ``head = top; ` ` `  `            ``// points to the last node so far of ` `            ``// the final merged list ` `            ``last = top; ` `        ``} ` ` `  `        ``else` `{ ` `            ``// insert 'top' at the end of the merged list so far ` `            ``last->next = top; ` ` `  `            ``// update the 'last' pointer ` `            ``last = top; ` `        ``} ` `    ``} ` ` `  `    ``// head node of the required merged list ` `    ``return` `head; ` `} ` ` `  `// function to print the singly linked list ` `void` `printList(``struct` `Node* head) ` `{ ` `    ``while` `(head != NULL) { ` `        ``cout << head->data << ``" "``; ` `        ``head = head->next; ` `    ``} ` `} ` ` `  `// Utility function to create a new node ` `struct` `Node* newNode(``int` `data) ` `{ ` `    ``// allocate node ` `    ``struct` `Node* new_node = ``new` `Node(); ` ` `  `    ``// put in the data ` `    ``new_node->data = data; ` `    ``new_node->next = NULL; ` ` `  `    ``return` `new_node; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``int` `k = 3; ``// Number of linked lists ` `    ``int` `n = 4; ``// Number of elements in each list ` ` `  `    ``// an array of pointers storing the head nodes ` `    ``// of the linked lists ` `    ``Node* arr[k]; ` ` `  `    ``// creating k = 3 sorted lists ` `    ``arr = newNode(1); ` `    ``arr->next = newNode(3); ` `    ``arr->next->next = newNode(5); ` `    ``arr->next->next->next = newNode(7); ` ` `  `    ``arr = newNode(2); ` `    ``arr->next = newNode(4); ` `    ``arr->next->next = newNode(6); ` `    ``arr->next->next->next = newNode(8); ` ` `  `    ``arr = newNode(0); ` `    ``arr->next = newNode(9); ` `    ``arr->next->next = newNode(10); ` `    ``arr->next->next->next = newNode(11); ` ` `  `    ``// merge the k sorted lists ` `    ``struct` `Node* head = mergeKSortedLists(arr, k); ` ` `  `    ``// print the merged list ` `    ``printList(head); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to merge k sorted linked lists ` `// Using MIN HEAP method ` `import` `java.util.PriorityQueue; ` `import` `java.util.Comparator; ` `public` `class` `MergeKLists { ` ` `  `    ``// function to merge k sorted linked lists ` `    ``public` `static` `Node mergeKSortedLists(Node arr[], ``int` `k) ` `    ``{ ` `        ``Node head = ``null``, last = ``null``; ` ` `  `        ``// priority_queue 'pq' implemeted as min heap with the ` `        ``// help of 'compare' function ` `        ``PriorityQueue pq = ``new` `PriorityQueue<>(``new` `Comparator() { ` `            ``public` `int` `compare(Node a, Node b) ` `            ``{ ` `                ``return` `a.data - b.data; ` `            ``} ` `        ``}); ` ` `  `        ``// push the head nodes of all the k lists in 'pq' ` `        ``for` `(``int` `i = ``0``; i < k; i++) ` `            ``if` `(arr[i] != ``null``) ` `                ``pq.add(arr[i]); ` ` `  `        ``// loop till 'pq' is not empty ` `        ``while` `(!pq.isEmpty()) { ` `            ``// get the top element of 'pq' ` `            ``Node top = pq.peek(); ` `            ``pq.remove(); ` ` `  `            ``// check if there is a node next to the 'top' node ` `            ``// in the list of which 'top' node is a member ` `            ``if` `(top.next != ``null``) ` `                ``// push the next node in 'pq' ` `                ``pq.add(top.next); ` ` `  `            ``// if final merged list is empty ` `            ``if` `(head == ``null``) { ` `                ``head = top; ` `                ``// points to the last node so far of ` `                ``// the final merged list ` `                ``last = top; ` `            ``} ` `            ``else` `{ ` `                ``// insert 'top' at the end of the merged list so far ` `                ``last.next = top; ` `                ``// update the 'last' pointer ` `                ``last = top; ` `            ``} ` `        ``} ` `        ``// head node of the required merged list ` `        ``return` `head; ` `    ``} ` ` `  `    ``// function to print the singly linked list ` `    ``public` `static` `void` `printList(Node head) ` `    ``{ ` `        ``while` `(head != ``null``) { ` `            ``System.out.print(head.data + ``" "``); ` `            ``head = head.next; ` `        ``} ` `    ``} ` ` `  `    ``// Utility function to create a new node ` `    ``public` `Node push(``int` `data) ` `    ``{ ` `        ``Node newNode = ``new` `Node(data); ` `        ``newNode.next = ``null``; ` `        ``return` `newNode; ` `    ``} ` ` `  `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `k = ``3``; ``// Number of linked lists ` `        ``int` `n = ``4``; ``// Number of elements in each list ` ` `  `        ``// an array of pointers storing the head nodes ` `        ``// of the linked lists ` `        ``Node arr[] = ``new` `Node[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``); ` ` `  `        ``// Merge all lists ` `        ``Node head = mergeKSortedLists(arr, k); ` `        ``printList(head); ` `    ``} ` `} ` ` `  `class` `Node { ` `    ``int` `data; ` `    ``Node next; ` `    ``Node(``int` `data) ` `    ``{ ` `        ``this``.data = data; ` `        ``next = ``null``; ` `    ``} ` `} ` `// This code is contributed by Gaurav Tiwari `

Output:

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

Time Complexity: O(nk Logk)
Auxiliary Space: O(k)

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using 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 :

14

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