# Merge K sorted Doubly Linked List in Sorted Order

• Difficulty Level : Medium
• Last Updated : 29 Oct, 2021

Given K sorted doubly linked list. The task is to merge all sorted doubly linked list in single sorted doubly linked list means final list must be sorted.
Examples:

Input:
List 1 : 2 <-> 7 <-> 8 <-> 12 <-> 15 <-> NULL
List 2 : 4 <-> 9 <-> 10 <-> NULL
List 3 : 5 <-> 9 <-> 11 <-> 16 <-> NULL
Output: 2 4 5 7 8 9 9 10 11 12 15 16
Input:
List 1 : 4 <-> 7 <-> 8 <-> 10 <-> NULL
List 2 : 4 <-> 19 <-> 20 <-> 23 <-> 27 <-> NULL
List 3 : 3 <-> 9 <-> 12 <-> 20 <-> NULL
List 4 : 1 <-> 19 <-> 22 <-> NULL
List 5 : 7 <-> 16 <-> 20 <-> 21 <-> NULL
Output :
1 3 4 4 7 7 8 9 10 12 16 19 19 20 20 20 21 22 23 27

Prerequisite: Reference-of-algorithm
Approach:

1. First merge two doubly linked list in sorted order
2. Then merge this list with another list in sorted order
3. Do the same thing until all list are not merged
4. Keep in mind that you have to merge two list at a time then merged list will be merged newly list

Algorithm:

```function merge(A, B) is
inputs A, B : list
returns list

C := new empty list
while A is not empty and B is not empty do
else

// By now, either A or B is empty
// It remains to empty the other input list
while A is not empty do
while B is not empty do

return C```

Below is the implementation of the above approach:

## C++

 `// C++ program to merge K sorted doubly``// linked list in sorted order``#include ``using` `namespace` `std;` `// A linked list node``struct` `Node {``    ``int` `data;``    ``Node* next;``    ``Node* prev;``};` `// Given a reference (pointer to pointer) to the head``// Of a DLL and an int, appends a new node at the end``void` `append(``struct` `Node** head_ref, ``int` `new_data)``{``    ``// Allocate node``    ``struct` `Node* new_node``        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));` `    ``struct` `Node* last = *head_ref;` `    ``// Put in the data``    ``new_node->data = new_data;` `    ``// This new node is going to be the last``    ``// node, so make next of it as NULL``    ``new_node->next = NULL;` `    ``// If the Linked List is empty, then make``    ``// the new node as head */``    ``if` `(*head_ref == NULL) {``        ``new_node->prev = NULL;``        ``*head_ref = new_node;``        ``return``;``    ``}` `    ``// Else traverse till the last node``    ``while` `(last->next != NULL)``        ``last = last->next;` `    ``// Change the next of last node``    ``last->next = new_node;` `    ``// Make last node as previous of new node``    ``new_node->prev = last;` `    ``return``;``}` `// Function to print the list``void` `printList(Node* node)``{``    ``Node* last;` `    ``// Run while loop unless node becomes null``    ``while` `(node != NULL) {``        ``cout << node->data << ``" "``;``        ``last = node;``        ``node = node->next;``    ``}``}` `// Function to merge two``// sorted doubly linked lists``Node* mergeList(Node* p, Node* q)``{``    ``Node* s = NULL;` `    ``// If any of the list is empty``    ``if` `(p == NULL || q == NULL) {``        ``return` `(p == NULL ? q : p);``    ``}` `    ``// Comparison the data of two linked list``    ``if` `(p->data < q->data) {``        ``p->prev = s;``        ``s = p;``        ``p = p->next;``    ``}``    ``else` `{``        ``q->prev = s;``        ``s = q;``        ``q = q->next;``    ``}` `    ``// Store head pointer before merge the list``    ``Node* head = s;``    ``while` `(p != NULL && q != NULL) {``        ``if` `(p->data < q->data) {` `            ``// Changing of pointer between``            ``// Two list for merging``            ``s->next = p;``            ``p->prev = s;``            ``s = s->next;``            ``p = p->next;``        ``}``        ``else` `{` `            ``// Changing of pointer between``            ``// Two list for merging``            ``s->next = q;``            ``q->prev = s;``            ``s = s->next;``            ``q = q->next;``        ``}``    ``}` `    ``// Condition to check if any anyone list not end``    ``if` `(p == NULL) {``        ``s->next = q;``        ``q->prev = s;``    ``}``    ``if` `(q == NULL) {``        ``s->next = p;``        ``p->prev = s;``    ``}` `    ``// Return head pointer of merged list``    ``return` `head;``}` `// Function to merge all sorted linked``// list in sorted order``Node* mergeAllList(Node* head[], ``int` `k)``{``    ``Node* finalList = NULL;``    ``for` `(``int` `i = 0; i < k; i++) {` `        ``// Function call to merge two sorted``        ``// doubly linked list at a time``        ``finalList = mergeList(finalList, head[i]);``    ``}` `    ``// Return final sorted doubly linked list``    ``return` `finalList;``}` `// Driver code``int` `main()``{``    ``int` `k = 3;``    ``Node* head[k];` `    ``// Loop to initialize all the lists to empty``    ``for` `(``int` `i = 0; i < k; i++) {``        ``head[i] = NULL;``    ``}` `    ``// Create first doubly linked List``    ``// List1 -> 1 <=> 5 <=> 9``    ``append(&head, 1);` `    ``append(&head, 5);` `    ``append(&head, 9);` `    ``// Create second doubly linked List``    ``// List2 -> 2 <=> 3 <=> 7 <=> 12``    ``append(&head, 2);` `    ``append(&head, 3);` `    ``append(&head, 7);` `    ``append(&head, 12);` `    ``// Create third doubly linked List``    ``// List3 -> 8 <=> 11 <=> 13 <=> 18``    ``append(&head, 8);` `    ``append(&head, 11);` `    ``append(&head, 13);` `    ``append(&head, 18);` `    ``// Function call to merge all sorted``    ``// doubly linked lists in sorted order``    ``Node* finalList = mergeAllList(head, k);` `    ``// Print final sorted list``    ``printList(finalList);` `    ``return` `0;``}`

## Java

 `// Java program to merge K sorted doubly``// linked list in sorted order``class` `GFG``{``    ` `// A linked list node``static` `class` `Node``{``    ``int` `data;``    ``Node next;``    ``Node prev;``};` `// Given a reference (pointer to pointer) to the head``// Of a DLL and an int, appends a new node at the end``static` `Node append(Node head_ref, ``int` `new_data)``{``    ``// Allocate node``    ``Node new_node = ``new` `Node();` `    ``Node last = head_ref;` `    ``// Put in the data``    ``new_node.data = new_data;` `    ``// This new node is going to be the last``    ``// node, so make next of it as null``    ``new_node.next = ``null``;` `    ``// If the Linked List is empty, then make``    ``// the new node as head */``    ``if` `(head_ref == ``null``)``    ``{``        ``new_node.prev = ``null``;``        ``head_ref = new_node;``        ``return` `head_ref;``    ``}` `    ``// Else traverse till the last node``    ``while` `(last.next != ``null``)``        ``last = last.next;` `    ``// Change the next of last node``    ``last.next = new_node;` `    ``// Make last node as previous of new node``    ``new_node.prev = last;` `    ``return` `head_ref;``}` `// Function to print the list``static` `void` `printList(Node node)``{``    ``Node last;` `    ``// Run while loop unless node becomes null``    ``while` `(node != ``null``)``    ``{``        ``System.out.print( node.data + ``" "``);``        ``last = node;``        ``node = node.next;``    ``}``}` `// Function to merge two``// sorted doubly linked lists``static` `Node mergeList(Node p, Node q)``{``    ``Node s = ``null``;` `    ``// If any of the list is empty``    ``if` `(p == ``null` `|| q == ``null``)``    ``{``        ``return` `(p == ``null` `? q : p);``    ``}` `    ``// Comparison the data of two linked list``    ``if` `(p.data < q.data)``    ``{``        ``p.prev = s;``        ``s = p;``        ``p = p.next;``    ``}``    ``else``    ``{``        ``q.prev = s;``        ``s = q;``        ``q = q.next;``    ``}` `    ``// Store head pointer before merge the list``    ``Node head = s;``    ``while` `(p != ``null` `&& q != ``null``)``    ``{``        ``if` `(p.data < q.data)``        ``{` `            ``// Changing of pointer between``            ``// Two list for merging``            ``s.next = p;``            ``p.prev = s;``            ``s = s.next;``            ``p = p.next;``        ``}``        ``else``        ``{` `            ``// Changing of pointer between``            ``// Two list for merging``            ``s.next = q;``            ``q.prev = s;``            ``s = s.next;``            ``q = q.next;``        ``}``    ``}` `    ``// Condition to check if any anyone list not end``    ``if` `(p == ``null``)``    ``{``        ``s.next = q;``        ``q.prev = s;``    ``}``    ``if` `(q == ``null``)``    ``{``        ``s.next = p;``        ``p.prev = s;``    ``}` `    ``// Return head pointer of merged list``    ``return` `head;``}` `// Function to merge all sorted linked``// list in sorted order``static` `Node mergeAllList(Node head[], ``int` `k)``{``    ``Node finalList = ``null``;``    ``for` `(``int` `i = ``0``; i < k; i++)``    ``{` `        ``// Function call to merge two sorted``        ``// doubly linked list at a time``        ``finalList = mergeList(finalList, head[i]);``    ``}` `    ``// Return final sorted doubly linked list``    ``return` `finalList;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``int` `k = ``3``;``    ``Node head[] = ``new` `Node[k];` `    ``// Loop to initialize all the lists to empty``    ``for` `(``int` `i = ``0``; i < k; i++)``    ``{``        ``head[i] = ``null``;``    ``}` `    ``// Create first doubly linked List``    ``// List1 . 1 <=> 5 <=> 9``    ``head[``0``] = append(head[``0``], ``1``);` `    ``head[``0``] = append(head[``0``], ``5``);` `    ``head[``0``] = append(head[``0``], ``9``);` `    ``// Create second doubly linked List``    ``// List2 . 2 <=> 3 <=> 7 <=> 12``    ``head[``1``] = append(head[``1``], ``2``);` `    ``head[``1``] = append(head[``1``], ``3``);`` ` `    ``head[``1``] = append(head[``1``], ``7``);` `    ``head[``1``] = append(head[``1``], ``12``);` `    ``// Create third doubly linked List``    ``// List3 . 8 <=> 11 <=> 13 <=> 18``    ``head[``2``] = append(head[``2``], ``8``);` `    ``head[``2``] = append(head[``2``], ``11``);` `    ``head[``2``] = append(head[``2``], ``13``);` `    ``head[``2``] = append(head[``2``], ``18``);` `    ``// Function call to merge all sorted``    ``// doubly linked lists in sorted order``    ``Node finalList = mergeAllList(head, k);` `    ``// Print final sorted list``    ``printList(finalList);``}``}` `// This code is contributed by Arnab Kundu`

## Python

 `# Python program to merge K sorted doubly``# linked list in sorted order` `# A linked list node``class` `Node:``    ``def` `__init__(``self``, new_data):``        ``self``.data ``=` `new_data``        ``self``.``next` `=` `None``        ``self``.prev ``=` `None` `# Given a reference (pointer to pointer) to the head``# Of a DLL and an int, appends a new node at the end``def` `append(head_ref, new_data):` `    ``# Allocate node``    ``new_node ``=` `Node(``0``)` `    ``last ``=` `head_ref` `    ``# Put in the data``    ``new_node.data ``=` `new_data` `    ``# This new node is going to be the last``    ``# node, so make next of it as None``    ``new_node.``next` `=` `None` `    ``# If the Linked List is empty, then make``    ``# the new node as head */``    ``if` `(head_ref ``=``=` `None``) :``        ``new_node.prev ``=` `None``        ``head_ref ``=` `new_node``        ``return` `head_ref``    ` `    ``# Else traverse till the last node``    ``while` `(last.``next` `!``=` `None``):``        ``last ``=` `last.``next` `    ``# Change the next of last node``    ``last.``next` `=` `new_node` `    ``# Make last node as previous of new node``    ``new_node.prev ``=` `last` `    ``return` `head_ref` `# Function to print the list``def` `printList(node):` `    ``last ``=` `None` `    ``# Run while loop unless node becomes None``    ``while` `(node !``=` `None``) :``    ` `        ``print``( node.data, end ``=` `" "``)``        ``last ``=` `node``        ``node ``=` `node.``next``    ` `# Function to merge two``# sorted doubly linked lists``def` `mergeList(p, q):` `    ``s ``=` `None` `    ``# If any of the list is empty``    ``if` `(p ``=``=` `None` `or` `q ``=``=` `None``) :``    ` `        ``if` `(p ``=``=` `None` `):``            ``return` `q``        ``else``:``            ``return` `p``    ` `    ``# Comparison the data of two linked list``    ``if` `(p.data < q.data):``        ``p.prev ``=` `s``        ``s ``=` `p``        ``p ``=` `p.``next``    ` `    ``else``:``        ``q.prev ``=` `s``        ``s ``=` `q``        ``q ``=` `q.``next``    ` `    ``# Store head pointer before merge the list``    ``head ``=` `s``    ``while` `(p !``=` `None` `and` `q !``=` `None``) :``    ` `        ``if` `(p.data < q.data) :``        ` `            ``# Changing of pointer between``            ``# Two list for merging``            ``s.``next` `=` `p``            ``p.prev ``=` `s``            ``s ``=` `s.``next``            ``p ``=` `p.``next``        ` `        ``else``:``            ``# Changing of pointer between``            ``# Two list for merging``            ``s.``next` `=` `q``            ``q.prev ``=` `s``            ``s ``=` `s.``next``            ``q ``=` `q.``next``        ` `    ``# Condition to check if any anyone list not end``    ``if` `(p ``=``=` `None``):``        ``s.``next` `=` `q``        ``q.prev ``=` `s``    ` `    ``if` `(q ``=``=` `None``):``        ``s.``next` `=` `p``        ``p.prev ``=` `s` `    ``# Return head pointer of merged list``    ``return` `head` `# Function to merge all sorted linked``# list in sorted order``def` `mergeAllList(head,k):` `    ``finalList ``=` `None``    ``i ``=` `0``    ``while` `( i < k ) :``    ` `        ``# Function call to merge two sorted``        ``# doubly linked list at a time``        ``finalList ``=` `mergeList(finalList, head[i])``        ``i ``=` `i ``+` `1``    ` `    ``# Return final sorted doubly linked list``    ``return` `finalList` `# Driver code` `k ``=` `3``head ``=` `[``0``] ``*` `k``i ``=` `0` `# Loop to initialize all the lists to empty``while` `( i < k ) :``    ` `    ``head[i] ``=` `None``    ``i ``=` `i ``+` `1``    ` `# Create first doubly linked List``# List1 . 1 <=> 5 <=> 9``head[``0``] ``=` `append(head[``0``], ``1``)``head[``0``] ``=` `append(head[``0``], ``5``)``head[``0``] ``=` `append(head[``0``], ``9``)` `# Create second doubly linked List``# List2 . 2 <=> 3 <=> 7 <=> 12``head[``1``] ``=` `append(head[``1``], ``2``)``head[``1``] ``=` `append(head[``1``], ``3``)``head[``1``] ``=` `append(head[``1``], ``7``)``head[``1``] ``=` `append(head[``1``], ``12``)` `# Create third doubly linked List``# List3 . 8 <=> 11 <=> 13 <=> 18``head[``2``] ``=` `append(head[``2``], ``8``)``head[``2``] ``=` `append(head[``2``], ``11``)``head[``2``] ``=` `append(head[``2``], ``13``)``head[``2``] ``=` `append(head[``2``], ``18``)` `# Function call to merge all sorted``# doubly linked lists in sorted order``finalList ``=` `mergeAllList(head, k)` `# Print final sorted list``printList(finalList)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# program to merge K sorted doubly``// linked list in sorted order``using` `System;` `class` `GFG``{``        ` `    ``// A linked list node``    ``public` `class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node next;``        ``public` `Node prev;``    ``};``    ` `    ``// Given a reference (pointer to pointer)``    ``// to the head of a DLL and an int,``    ``// appends a new node at the end``    ``static` `Node append(Node head_ref,``                       ``int` `new_data)``    ``{``        ``// Allocate node``        ``Node new_node = ``new` `Node();``    ` `        ``Node last = head_ref;``    ` `        ``// Put in the data``        ``new_node.data = new_data;``    ` `        ``// This new node is going to be the last``        ``// node, so make next of it as null``        ``new_node.next = ``null``;``    ` `        ``// If the Linked List is empty,``        ``// then make the new node as head */``        ``if` `(head_ref == ``null``)``        ``{``            ``new_node.prev = ``null``;``            ``head_ref = new_node;``            ``return` `head_ref;``        ``}``    ` `        ``// Else traverse till the last node``        ``while` `(last.next != ``null``)``            ``last = last.next;``    ` `        ``// Change the next of last node``        ``last.next = new_node;``    ` `        ``// Make last node as previous of new node``        ``new_node.prev = last;``    ` `        ``return` `head_ref;``    ``}``    ` `    ``// Function to print the list``    ``static` `void` `printList(Node node)``    ``{``        ``Node last;``    ` `        ``// Run while loop unless node becomes null``        ``while` `(node != ``null``)``        ``{``            ``Console.Write(node.data + ``" "``);``            ``last = node;``            ``node = node.next;``        ``}``    ``}``    ` `    ``// Function to merge two``    ``// sorted doubly linked lists``    ``static` `Node mergeList(Node p, Node q)``    ``{``        ``Node s = ``null``;``    ` `        ``// If any of the list is empty``        ``if` `(p == ``null` `|| q == ``null``)``        ``{``            ``return` `(p == ``null` `? q : p);``        ``}``    ` `        ``// Comparison the data of two linked list``        ``if` `(p.data < q.data)``        ``{``            ``p.prev = s;``            ``s = p;``            ``p = p.next;``        ``}``        ``else``        ``{``            ``q.prev = s;``            ``s = q;``            ``q = q.next;``        ``}``    ` `        ``// Store head pointer before merge the list``        ``Node head = s;``        ``while` `(p != ``null` `&& q != ``null``)``        ``{``            ``if` `(p.data < q.data)``            ``{``    ` `                ``// Changing of pointer between``                ``// Two list for merging``                ``s.next = p;``                ``p.prev = s;``                ``s = s.next;``                ``p = p.next;``            ``}``            ``else``            ``{``    ` `                ``// Changing of pointer between``                ``// Two list for merging``                ``s.next = q;``                ``q.prev = s;``                ``s = s.next;``                ``q = q.next;``            ``}``        ``}``    ` `        ``// Condition to check if``        ``// any anyone list not end``        ``if` `(p == ``null``)``        ``{``            ``s.next = q;``            ``q.prev = s;``        ``}``        ``if` `(q == ``null``)``        ``{``            ``s.next = p;``            ``p.prev = s;``        ``}``    ` `        ``// Return head pointer of merged list``        ``return` `head;``    ``}``    ` `    ``// Function to merge all sorted linked``    ``// list in sorted order``    ``static` `Node mergeAllList(Node []head, ``int` `k)``    ``{``        ``Node finalList = ``null``;``        ``for` `(``int` `i = 0; i < k; i++)``        ``{``    ` `            ``// Function call to merge two sorted``            ``// doubly linked list at a time``            ``finalList = mergeList(finalList,``                                   ``head[i]);``        ``}``    ` `        ``// Return final sorted doubly linked list``        ``return` `finalList;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `k = 3;``        ``Node []head = ``new` `Node[k];``    ` `        ``// Loop to initialize all the lists to empty``        ``for` `(``int` `i = 0; i < k; i++)``        ``{``            ``head[i] = ``null``;``        ``}``    ` `        ``// Create first doubly linked List``        ``// List1 . 1 <=> 5 <=> 9``        ``head = append(head, 1);``        ``head = append(head, 5);``        ``head = append(head, 9);``    ` `        ``// Create second doubly linked List``        ``// List2 . 2 <=> 3 <=> 7 <=> 12``        ``head = append(head, 2);``        ``head = append(head, 3);``        ``head = append(head, 7);``        ``head = append(head, 12);``    ` `        ``// Create third doubly linked List``        ``// List3 . 8 <=> 11 <=> 13 <=> 18``        ``head = append(head, 8);``        ``head = append(head, 11);``        ``head = append(head, 13);``        ``head = append(head, 18);``    ` `        ``// Function call to merge all sorted``        ``// doubly linked lists in sorted order``        ``Node finalList = mergeAllList(head, k);``    ` `        ``// Print final sorted list``        ``printList(finalList);``    ``}``}` `// This code is contributed by AnkitRai01`

## Javascript

 ``

Output:

`1 2 3 5 7 8 9 11 12 13 18`

My Personal Notes arrow_drop_up