 GFG App
Open App Browser
Continue

# Sort a k sorted doubly linked list

Given a doubly linked list containing n nodes, where each node is at most k away from its target position in the list. The problem is to sort the given doubly linked list.
For example, let us consider k is 2, a node at position 7 in the sorted doubly linked list, can be at positions 5, 6, 7, 8, 9 in the given doubly linked list.

Examples: Naive Approach: Sort the given doubly linked list using the insertion sort technique. While inserting each element in the sorted part of the list, there will be at most k swaps to place the element to its correct position since it is at most k steps away from its correct position.

## C++

 `// C++ implementation to sort a k sorted doubly` `// linked list` `#include` `using` `namespace` `std;`   `// a node of the doubly linked list` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `    ``struct` `Node* prev;` `};`     `// function to sort a k sorted doubly linked list` `struct` `Node* sortAKSortedDLL(``struct` `Node* head, ``int` `k)` `{` `    ``if``(head == NULL || head->next == NULL)` `        ``return` `head;` ` `  `    ``// perform on all the nodes in list` `    ``for``(Node *i = head->next; i != NULL; i = i->next) {` `        ``Node *j = i;` `          ``// There will be atmost k swaps for each element in the list` `        ``// since each node is k steps away from its correct position` `        ``while``(j->prev != NULL && j->data < j->prev->data) {` `              ``// swap j and j.prev node` `            ``Node* temp = j->prev->prev;` `            ``Node* temp2 = j->prev;` `            ``Node *temp3 = j->next;` `            ``j->prev->next = temp3;` `            ``j->prev->prev = j;` `            ``j->prev = temp;` `            ``j->next = temp2;` `            ``if``(temp != NULL)` `                ``temp->next = j;` `            ``if``(temp3 != NULL)` `                ``temp3->prev = temp2;` `        ``}` `          ``// if j is now the new head` `       ``// then reset head` `        ``if``(j->prev == NULL)` `            ``head = j;` `    ``}` `    ``return` `head;` `}`   `// Function to insert a node at the beginning` `// of the Doubly Linked List` `void` `push(``struct` `Node** head_ref, ``int` `new_data)` `{` `    ``// allocate node` `    ``struct` `Node* new_node =` `        ``(``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``// put in the data` `    ``new_node->data = new_data;`   `    ``// since we are adding at the beginning,` `    ``// prev is always NULL` `    ``new_node->prev = NULL;`   `    ``// link the old list of the new node` `    ``new_node->next = (*head_ref);`   `    ``// change prev of head node to new node` `    ``if` `((*head_ref) != NULL)` `        ``(*head_ref)->prev = new_node;`   `    ``// move the head to point to the new node` `    ``(*head_ref) = new_node;` `}`   `// Function to print nodes in a given doubly linked list` `void` `printList(``struct` `Node* head)` `{` `    ``// if list is empty` `    ``if` `(head == NULL)` `        ``cout << ``"Doubly Linked list empty"``;`   `    ``while` `(head != NULL) {` `        ``cout << head->data << ``" "``;` `        ``head = head->next;` `    ``}` `}`   `// Driver program to test above` `int` `main()` `{` `    ``struct` `Node* head = NULL;`   `    ``// Create the doubly linked list:` `    ``// 3<->6<->2<->12<->56<->8` `    ``push(&head, 8);` `    ``push(&head, 56);` `    ``push(&head, 12);` `    ``push(&head, 2);` `    ``push(&head, 6);` `    ``push(&head, 3);`   `    ``int` `k = 2;`   `    ``cout << ``"Original Doubly linked list:\n"``;` `    ``printList(head);`   `    ``// sort the biotonic DLL` `    ``head = sortAKSortedDLL(head, k);`   `    ``cout << ``"\nDoubly Linked List after sorting:\n"``;` `    ``printList(head);`   `    ``return` `0;` `}`   `// This code is contributed by sachinejain74754.`

## Java

 `// Java implementation to sort a k sorted doubly` `import` `java.util.*;` `class` `DoublyLinkedList` `{` `static` `Node head;` `static` `class` `Node` `{` `    ``int` `data;` `    ``Node next, prev;` `    ``Node(``int` `d)` `    ``{` `    ``data = d;` `    ``next = prev = ``null``;` `    ``}` `}`   `// function to sort a k sorted doubly linked list` `// Using Insertion Sort` `// Time Complexity: O(n*k)` `// Space Complexity: O(1)` `Node sortAKSortedDLL( Node head, ``int` `k) {` `      ``if``(head == ``null` `|| head.next == ``null``) ` `        ``return` `head;`   `    ``// perform on all the nodes in list` `    ``for``(Node i = head.next; i != ``null``; i = i.next) {` `        ``Node j = i;` `          ``// There will be atmost k swaps for each element in the list` `        ``// since each node is k steps away from its correct position` `        ``while``(j.prev != ``null` `&& j.data < j.prev.data) {` `              ``// swap j and j.prev node` `            ``Node temp = j.prev.prev;` `            ``Node temp2 = j.prev;` `            ``Node temp3 = j.next;` `            ``j.prev.next = temp3;` `            ``j.prev.prev = j;` `            ``j.prev = temp;` `            ``j.next = temp2;` `            ``if``(temp != ``null``)` `                ``temp.next = j;` `            ``if``(temp3 != ``null``)` `                ``temp3.prev = temp2;` `        ``}` `          ``// if j is now the new head` `       ``// then reset head` `        ``if``(j.prev == ``null``)` `            ``head = j;` `    ``}` `    ``return` `head;` `}`   `/* UTILITY FUNCTIONS */` `/* Function to insert a node at the beginning of the` `    ``* Doubly Linked List */` `void` `push(``int` `new_data)` `{` `    ``/* allocate node */` `    ``Node new_node = ``new` `Node(new_data);`   `    ``/* since we are adding at the beginning,` `        ``prev is always NULL */` `    ``new_node.prev = ``null``;`   `    ``/* link the old list of the new node */` `    ``new_node.next = head;`   `    ``/* change prev of head node to new node */` `    ``if` `(head != ``null``)` `    ``{` `    ``head.prev = new_node;` `    ``}`   `    ``/* move the head to point to the new node */` `    ``head = new_node;` `}`   `/* Function to print nodes in a given doubly linked list` `    ``This function is same as printList() of singly linked` `    ``list */` `void` `printList(Node node)` `{` `    ``while` `(node != ``null``)` `    ``{` `    ``System.out.print(node.data + ``" "``);` `    ``node = node.next;` `    ``}` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``DoublyLinkedList list = ``new` `DoublyLinkedList();`   `    ``/* Let us create a k sorted doubly linked list to test the` `        ``functions Created doubly linked list will be 3<->6<->2<->12<->56<->8` `    ``*/` `    ``list.push(``8``);` `    ``list.push(``56``);` `    ``list.push(``12``);` `    ``list.push(``2``);` `    ``list.push(``6``);` `    ``list.push(``3``);`   `    ``int` `k = ``2``;`   `    ``System.out.println(``"Original Doubly linked list:"``);` `    ``list.printList(head);`   `    ``Node sortedDLL = list.sortAKSortedDLL(head, k);` `    ``System.out.println(``""``);` `    ``System.out.println(``"Doubly Linked List after sorting:"``);` `    ``list.printList(sortedDLL);` `}` `}`   `// This code is contributed by Mittul Mandhan(@mittulmandhan)`

## Python3

 `# Python implementation to sort a k sorted doublyclass DoublyLinkedList {` `head ``=` `None`   `class` `Node:` `    ``def` `__init__(``self``, val):` `        ``self``.data ``=` `val` `        ``self``.prev ``=` `None` `        ``self``.``next` `=` `None`   `# function to sort a k sorted doubly linked list` `# Using Insertion Sort` `# Time Complexity: O(n*k)` `# Space Complexity: O(1)` `def` `sortAKSortedDLL(head , k):` `    ``if` `(head ``=``=` `None` `or` `head.``next` `=``=` `None``):` `        ``return` `head`   `    ``# perform on all the nodes in list` `    ``i ``=` `head.``next` `    ``while``(i !``=` `None``):` `        ``j ``=` `i` `        `  `        ``# There will be atmost k swaps for each element in the list` `        ``# since each node is k steps away from its correct position` `        ``while` `(j.prev !``=` `None` `and` `j.data < j.prev.data):` `          `  `            ``# swap j and j.prev node` `            ``temp ``=` `j.prev.prev` `            ``temp2 ``=` `j.prev` `            ``temp3 ``=` `j.``next` `            ``j.prev.``next` `=` `temp3` `            ``j.prev.prev ``=` `j` `            ``j.prev ``=` `temp` `            ``j.``next` `=` `temp2` `            ``if` `(temp !``=` `None``):` `                ``temp.``next` `=` `j` `            ``if` `(temp3 !``=` `None``):` `                ``temp3.prev ``=` `temp2` `                `  `            ``# if j is now the new head` `            ``# then reset head` `        ``if` `(j.prev ``=``=` `None``):` `            ``head ``=` `j` `        ``i ``=` `i.``next`   `    ``return` `head`   `# UTILITY FUNCTIONS ` `#` `# Function to insert a node at the beginning of the Doubly Linked List` `def` `push(new_data):`   `    ``global` `head` `    `  `    ``# allocate node` `    ``new_node ``=` `Node(new_data)`   `    ``#` `    ``# since we are adding at the beginning, prev is always NULL` `    ``#` `    ``new_node.prev ``=` `None`   `    ``# link the old list of the new node ` `    ``new_node.``next` `=` `head`   `    ``# change prev of head node to new node` `    ``if` `(head !``=` `None``):` `        ``head.prev ``=` `new_node`   `    ``# move the head to point to the new node` `    ``head ``=` `new_node`   `# Function to print nodes in a given doubly linked list This function is same` `# as printList() of singly linked list` `def` `printList(node):` `    ``while` `(node !``=` `None``):` `        ``print``(node.data,end ``=` `" "``)` `        ``node ``=` `node.``next`   `# Driver code`   `# Let us create a k sorted doubly linked list to test the functions Created` `# doubly linked list will be 3<->6<->2<->12<->56<->8` `push(``8``)` `push(``56``)` `push(``12``)` `push(``2``)` `push(``6``)` `push(``3``)`   `k ``=` `2`   `print``(``"Original Doubly linked list:"``)` `printList(head)`   `sortedDLL ``=` `sortAKSortedDLL(head, k)` `print``("")` `print``(``"Doubly Linked List after sorting:"``)` `printList(sortedDLL)`   `# This codeis contributed by shinjanpatra`

## C#

 `// C# implementation to sort a k sorted doubly lists` `using` `System;`   `class` `DoublyLinkedList {` `  ``static` `Node head;`   `  ``public` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node next, prev;` `    ``public` `Node(``int` `d)` `    ``{` `      ``data = d;` `      ``next = prev = ``null``;` `    ``}` `  ``}`   `  ``// function to sort a k sorted doubly linked list` `  ``// Using Insertion Sort` `  ``// Time Complexity: O(n*k)` `  ``// Space Complexity: O(1)` `  ``public` `Node sortAKSortedDLL(Node head, ``int` `k)` `  ``{` `    ``if` `(head == ``null` `|| head.next == ``null``)` `      ``return` `head;`   `    ``// perform on all the nodes in list` `    ``for` `(Node i = head.next; i != ``null``; i = i.next) {` `      ``Node j = i;`   `      ``// There will be atmost k swaps for each element` `      ``// in the list since each node is k steps away` `      ``// from its correct position` `      ``while` `(j.prev != ``null` `&& j.data < j.prev.data)` `      ``{`   `        ``// swap j and j.prev node` `        ``Node temp = j.prev.prev;` `        ``Node temp2 = j.prev;` `        ``Node temp3 = j.next;` `        ``j.prev.next = temp3;` `        ``j.prev.prev = j;` `        ``j.prev = temp;` `        ``j.next = temp2;` `        ``if` `(temp != ``null``)` `          ``temp.next = j;` `        ``if` `(temp3 != ``null``)` `          ``temp3.prev = temp2;` `      ``}`   `      ``// if j is now the new head` `      ``// then reset head` `      ``if` `(j.prev == ``null``)` `        ``head = j;` `    ``}` `    ``return` `head;` `  ``}`   `  ``/* UTILITY FUNCTIONS */` `  ``/* Function to insert a node at the beginning of the` `     ``* Doubly Linked List */` `  ``public` `void` `push(``int` `new_data)` `  ``{`   `    ``/* allocate node */` `    ``Node new_node = ``new` `Node(new_data);`   `    ``/* since we are adding at the beginning,` `        ``prev is always NULL */` `    ``new_node.prev = ``null``;`   `    ``/* link the old list of the new node */` `    ``new_node.next = head;`   `    ``/* change prev of head node to new node */` `    ``if` `(head != ``null``) {` `      ``head.prev = new_node;` `    ``}`   `    ``/* move the head to point to the new node */` `    ``head = new_node;` `  ``}`   `  ``/* Function to print nodes in a given doubly linked list` `    ``This function is same as printList() of singly linked` `    ``list */` `  ``public` `void` `printList(Node node)` `  ``{` `    ``while` `(node != ``null``) {` `      ``Console.Write(node.data + ``" "``);` `      ``node = node.next;` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``DoublyLinkedList list = ``new` `DoublyLinkedList();`   `    ``/* Let us create a k sorted doubly linked list to` `           ``test the functions Created doubly linked list` `           ``will be 3<->6<->2<->12<->56<->8` `        ``*/` `    ``list.push(8);` `    ``list.push(56);` `    ``list.push(12);` `    ``list.push(2);` `    ``list.push(6);` `    ``list.push(3);`   `    ``int` `k = 2;`   `    ``Console.WriteLine(``"Original Doubly linked list:"``);` `    ``list.printList(head);`   `    ``Node sortedDLL = list.sortAKSortedDLL(head, k);` `    ``Console.WriteLine();`   `    ``Console.WriteLine(` `      ``"Doubly Linked List after sorting:"``);` `    ``list.printList(sortedDLL);` `  ``}` `}`   `// This code is contributed by Tapesh (tapeshdua420)`

## Javascript

 ``

Output

```Original Doubly linked list:
3 6 2 12 56 8
2 3 6 8 12 56 ```

Time Complexity: O(n*k)
Auxiliary Space: O(1)

Efficient Approach: We can sort the list using the MIN HEAP data structure. The approach has been explained in Sort a nearly sorted (or K sorted) array. We only have to be careful while traversing the input doubly linked list and adjusting the required next and previous links in the final sorted list.

Implementation:

## CPP

 `// C++ implementation to sort a k sorted doubly` `// linked list` `#include ` `using` `namespace` `std;`   `// a node of the doubly linked list` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `    ``struct` `Node* prev;` `};`   `// 'compare' function used to build up the` `// priority queue` `struct` `compare {` `    ``bool` `operator()(``struct` `Node* p1, ``struct` `Node* p2)` `    ``{` `        ``return` `p1->data > p2->data;` `    ``}` `};`   `// function to sort a k sorted doubly linked list` `struct` `Node* sortAKSortedDLL(``struct` `Node* head, ``int` `k)` `{` `    ``// if list is empty` `    ``if` `(head == NULL)` `        ``return` `head;`   `    ``// priority_queue 'pq' implemented as min heap with the` `    ``// help of 'compare' function` `    ``priority_queue, compare> pq;`   `    ``struct` `Node* newHead = NULL, *last;`   `    ``// Create a Min Heap of first (k+1) elements from` `    ``// input doubly linked list` `    ``for` `(``int` `i = 0; head != NULL && i <= k; i++) {` `        ``// push the node on to 'pq'` `        ``pq.push(head);`   `        ``// move to the next node` `        ``head = head->next;` `    ``}`   `    ``// loop till there are elements in 'pq'` `    ``while` `(!pq.empty()) {`   `        ``// place root or top of 'pq' at the end of the` `        ``// result sorted list so far having the first node` `        ``// pointed to by 'newHead'` `        ``// and adjust the required links` `        ``if` `(newHead == NULL) {` `            ``newHead = pq.top();` `            ``newHead->prev = NULL;`   `            ``// 'last' points to the last node` `            ``// of the result sorted list so far` `            ``last = newHead;` `        ``}`   `        ``else` `{` `            ``last->next = pq.top();` `            ``pq.top()->prev = last;` `            ``last = pq.top();` `        ``}`   `        ``// remove element from 'pq'` `        ``pq.pop();`   `        ``// if there are more nodes left in the input list` `        ``if` `(head != NULL) {` `            ``// push the node on to 'pq'` `            ``pq.push(head);`   `            ``// move to the next node` `            ``head = head->next;` `        ``}` `    ``}`   `    ``// making 'next' of last node point to NULL` `    ``last->next = NULL;`   `    ``// new head of the required sorted DLL` `    ``return` `newHead;` `}`   `// Function to insert a node at the beginning` `// of the Doubly Linked List` `void` `push(``struct` `Node** head_ref, ``int` `new_data)` `{` `    ``// allocate node` `    ``struct` `Node* new_node = ` `          ``(``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``// put in the data` `    ``new_node->data = new_data;`   `    ``// since we are adding at the beginning,` `    ``// prev is always NULL` `    ``new_node->prev = NULL;`   `    ``// link the old list of the new node` `    ``new_node->next = (*head_ref);`   `    ``// change prev of head node to new node` `    ``if` `((*head_ref) != NULL)` `        ``(*head_ref)->prev = new_node;`   `    ``// move the head to point to the new node` `    ``(*head_ref) = new_node;` `}`   `// Function to print nodes in a given doubly linked list` `void` `printList(``struct` `Node* head)` `{` `    ``// if list is empty` `    ``if` `(head == NULL)` `        ``cout << ``"Doubly Linked list empty"``;`   `    ``while` `(head != NULL) {` `        ``cout << head->data << ``" "``;` `        ``head = head->next;` `    ``}` `}`   `// Driver program to test above` `int` `main()` `{` `    ``struct` `Node* head = NULL;`   `    ``// Create the doubly linked list:` `    ``// 3<->6<->2<->12<->56<->8` `    ``push(&head, 8);` `    ``push(&head, 56);` `    ``push(&head, 12);` `    ``push(&head, 2);` `    ``push(&head, 6);` `    ``push(&head, 3);`   `    ``int` `k = 2;`   `    ``cout << ``"Original Doubly linked list:\n"``;` `    ``printList(head);`   `    ``// sort the biotonic DLL` `    ``head = sortAKSortedDLL(head, k);`   `    ``cout << ``"\nDoubly Linked List after sorting:\n"``;` `    ``printList(head);`   `    ``return` `0;` `}`

## Java

 `// Java implementation to sort a k sorted doubly ` `import` `java.util.*;` `class` `DoublyLinkedList` `{` `  ``static` `Node head;` `  ``static` `class` `Node ` `  ``{` `    ``int` `data;` `    ``Node next, prev;` `    ``Node(``int` `d)` `    ``{` `      ``data = d;` `      ``next = prev = ``null``;` `    ``}` `  ``}` `  ``class` `compareNode ``implements` `Comparator` `  ``{` `    ``public` `int` `compare(Node n1, Node n2){` `      ``return` `n1.data-n2.data;` `    ``}` `  ``}`   `  ``// function to sort a k sorted doubly linked list ` `  ``Node sortAKSortedDLL( Node head, ``int` `k) ` `  ``{ ` `    `  `    ``// if list is empty ` `    ``if` `(head == ``null``) ` `      ``return` `head; `   `    ``// priority_queue 'pq' implemented as min heap with the ` `    ``// help of 'compare' function in compare Node class` `    ``PriorityQueue pq = ``new` `PriorityQueue(``new` `compareNode()); `   `    ``Node newHead = ``null``, last = ``null``; `   `    ``// Create a Min Heap of first (k+1) elements from ` `    ``// input doubly linked list ` `    ``for` `(``int` `i = ``0``; head != ``null` `&& i <= k; i++) ` `    ``{` `      `  `      ``// push the node on to 'pq' ` `      ``pq.add(head); `   `      ``// move to the next node ` `      ``head = head.next; ` `    ``} `   `    ``// loop till there are elements in 'pq' ` `    ``while` `(!pq.isEmpty())` `    ``{ `   `      ``// place root or top of 'pq' at the end of the ` `      ``// result sorted list so far having the first node ` `      ``// pointed to by 'newHead' ` `      ``// and adjust the required links ` `      ``if` `(newHead == ``null``) ` `      ``{ ` `        ``newHead = pq.peek(); ` `        ``newHead.prev = ``null``; `   `        ``// 'last' points to the last node ` `        ``// of the result sorted list so far ` `        ``last = newHead; ` `      ``} `   `      ``else` `      ``{ ` `        ``last.next = pq.peek(); ` `        ``pq.peek().prev = last; ` `        ``last = pq.peek(); ` `      ``} `   `      ``// remove element from 'pq' ` `      ``pq.poll(); `   `      ``// if there are more nodes left in the input list ` `      ``if` `(head != ``null``) ` `      ``{` `        `  `        ``// push the node on to 'pq' ` `        ``pq.add(head); `   `        ``// move to the next node ` `        ``head = head.next; ` `      ``} ` `    ``} `   `    ``// making 'next' of last node point to NULL ` `    ``last.next = ``null``; `   `    ``// new head of the required sorted DLL ` `    ``return` `newHead; ` `  ``} `   `  ``/* UTILITY FUNCTIONS */` `  ``/* Function to insert a node at the beginning of the` `     ``* Doubly Linked List */` `  ``void` `push(``int` `new_data)` `  ``{` `    ``/* allocate node */` `    ``Node new_node = ``new` `Node(new_data);`   `    ``/* since we are adding at the beginning,` `         ``prev is always NULL */` `    ``new_node.prev = ``null``;`   `    ``/* link the old list of the new node */` `    ``new_node.next = head;`   `    ``/* change prev of head node to new node */` `    ``if` `(head != ``null``) ` `    ``{` `      ``head.prev = new_node;` `    ``}`   `    ``/* move the head to point to the new node */` `    ``head = new_node;` `  ``}`   `  ``/* Function to print nodes in a given doubly linked list` `     ``This function is same as printList() of singly linked` `     ``list */` `  ``void` `printList(Node node)` `  ``{` `    ``while` `(node != ``null``)` `    ``{` `      ``System.out.print(node.data + ``" "``);` `      ``node = node.next;` `    ``}` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``DoublyLinkedList list = ``new` `DoublyLinkedList();`   `    ``/* Let us create a k sorted doubly linked list to test the` `         ``functions Created doubly linked list will be 3<->6<->2<->12<->56<->8 ` `       ``*/` `    ``list.push(``8``);` `    ``list.push(``56``);` `    ``list.push(``12``);` `    ``list.push(``2``);` `    ``list.push(``6``);` `    ``list.push(``3``);`   `    ``int` `k = ``2``;`   `    ``System.out.println(``"Original Doubly linked list:"``);` `    ``list.printList(head);`   `    ``Node sortedDLL = list.sortAKSortedDLL(head, k);` `    ``System.out.println(``""``);` `    ``System.out.println(``"Doubly Linked List after sorting:"``);` `    ``list.printList(sortedDLL);` `  ``}` `}`   `// This code is contributed by Kushagra Keserwani`

## Python3

 `# Python implementation to sort a k sorted doubly linked list` `import` `heapq` `head ``=` `None`   `#  a node of the doubly linked list` `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None` `        ``self``.prev ``=` `None`   `# function to sort a k sorted doubly linked list` `def` `sortAKSortedDLL(head, k):` `    ``# if list is empty` `    ``if` `head ``=``=` `None``:` `        ``return` `head`   `    ``pq ``=` `[]`   `    ``newHead ``=` `None` `    ``last ``=` `None`   `    ``for` `i ``in` `range``(k``+``1``):` `        ``# push the node` `        ``heapq.heappush(pq, (head.data, head))` `        ``# move to the next node` `        ``head ``=` `head.``next`   `    ``# loop till there are elements in 'pq'` `    ``while` `len``(pq) > ``0``:`   `        ``if` `newHead ``=``=` `None``:` `            ``newHead ``=` `heapq.heappop(pq)[``1``]` `            ``newHead.prev ``=` `None`   `        ``#  'last' points to the last node of the result sorted list so far` `            ``last ``=` `newHead` `        ``else``:` `            ``last.``next` `=` `heapq.heappop(pq)[``1``]` `            ``last.``next``.prev ``=` `last` `            ``last ``=` `last.``next`   `        ``# if there are more nodes left in the input list` `        ``if` `head !``=` `None``:` `            ``# push the node` `            ``heapq.heappush(pq, (head.data, head))`   `            ``# move to the next node` `            ``head ``=` `head.``next`   `    ``# making 'next' of last node point to NULL` `    ``last.``next` `=` `None`   `    ``# new head of the required sorted DLL` `    ``return` `newHead`   `# Function to insert a node at the beginning of the Doubly Linked List` `def` `push(new_data):`   `    ``global` `head`   `    ``# allocate node` `    ``new_node ``=` `Node(new_data)`   `    ``# since we are adding at the beginning, prev is always NULL` `    ``new_node.prev ``=` `None`   `    ``# link the old list of the new node` `    ``new_node.``next` `=` `head`   `    ``# change prev of head node to new node` `    ``if` `(head !``=` `None``):` `        ``head.prev ``=` `new_node`   `    ``# move the head to point to the new node` `    ``head ``=` `new_node`     `# Function to print nodes in a given doubly linked list` `def` `printList(head):` `    ``# if list is empty` `    ``if` `head ``is` `None``:` `        ``print``(``"Doubly Linked list empty"``)`   `    ``while` `head ``is` `not` `None``:` `        ``print``(head.data, end``=``" "``)` `        ``head ``=` `head.``next`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Create the doubly linked list:` `    ``# 3<->6<->2<->12<->56<->8` `    ``push(``8``)` `    ``push(``56``)` `    ``push(``12``)` `    ``push(``2``)` `    ``push(``6``)` `    ``push(``3``)`   `    ``k ``=` `2`   `    ``print``(``"Original Doubly linked list:"``)` `    ``printList(head)`   `    ``sortedDLL ``=` `sortAKSortedDLL(head, k)`   `    ``print``(``"\nDoubly Linked List after sorting:"``)` `    ``printList(sortedDLL)`   `# This code is contributed by Tapesh(tapeshdua420)`

## C#

 `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `// C# implementation to sort a k sorted doubly ` `class` `Node ` `{` `  ``public` `int` `data;` `  ``public` `Node next, prev;` `  ``public` `Node(``int` `d)` `  ``{` `    ``data = d;` `    ``next = prev = ``null``;` `  ``}` `}`   `class` `DoublyLinkedList` `{`   `  ``public`   `Node head;` `  ``// function to sort a k sorted doubly linked list ` `  ``public`  `Node sortAKSortedDLL(Node head, ``int` `k) ` `  ``{ `   `    ``// if list is empty ` `    ``if` `(head == ``null``) ` `      ``return` `head; `   `    ``// priority_queue 'pq' implemented as min heap with the ` `    ``// help of 'compare' function in compare Node class` `    ``List pq = ``new` `List();`   `    ``Node newHead = ``null``, last = ``null``; `   `    ``// Create a Min Heap of first (k+1) elements from ` `    ``// input doubly linked list ` `    ``for` `(``int` `i = 0; head != ``null` `&& i <= k; i++) ` `    ``{`   `      ``// push the node on to 'pq' ` `      ``pq.Add(head); ` `      ``pq.Sort(``delegate``(Node x, Node y){` `        ``return` `x.data.CompareTo(y.data);` `      ``});` `      ``// move to the next node ` `      ``head = head.next; ` `    ``} `   `    ``// loop till there are elements in 'pq' ` `    ``while` `(pq.Count > 0)` `    ``{ `   `      ``// place root or top of 'pq' at the end of the ` `      ``// result sorted list so far having the first node ` `      ``// pointed to by 'newHead' ` `      ``// and adjust the required links ` `      ``if` `(newHead == ``null``) ` `      ``{ ` `        ``newHead = pq; ` `        ``newHead.prev = ``null``; `   `        ``// 'last' points to the last node ` `        ``// of the result sorted list so far ` `        ``last = newHead; ` `      ``} `   `      ``else` `      ``{ ` `        ``last.next = pq; ` `        ``pq.prev = last; ` `        ``last = pq; ` `      ``} `   `      ``// remove element from 'pq' ` `      ``pq.RemoveAt(0); `   `      ``// if there are more nodes left in the input list ` `      ``if` `(head != ``null``) ` `      ``{`   `        ``// push the node on to 'pq' ` `        ``pq.Add(head); ` `        ``pq.Sort(``delegate``(Node x, Node y){` `          ``return` `x.data.CompareTo(y.data);` `        ``});` `        ``// move to the next node ` `        ``head = head.next; ` `      ``} ` `    ``} `   `    ``// making 'next' of last node point to NULL ` `    ``last.next = ``null``; `   `    ``// new head of the required sorted DLL ` `    ``return` `newHead; ` `  ``} `   `  ``/* UTILITY FUNCTIONS */` `  ``/* Function to insert a node at the beginning of the` `     ``* Doubly Linked List */` `  ``public`  `Node push(``int` `new_data)` `  ``{` `    ``/* allocate node */` `    ``Node new_node = ``new` `Node(new_data);`   `    ``/* since we are adding at the beginning,` `         ``prev is always NULL */` `    ``new_node.prev = ``null``;`   `    ``/* link the old list of the new node */` `    ``new_node.next = head;`   `    ``/* change prev of head node to new node */` `    ``if` `(head != ``null``) ` `    ``{` `      ``head.prev = new_node;` `    ``}`   `    ``/* move the head to point to the new node */` `    ``head = new_node;`   `    ``return` `head;` `  ``}`   `  ``/* Function to print nodes in a given doubly linked list` `     ``This function is same as printList() of singly linked` `     ``list */` `  ``public` `void` `printList(Node node)` `  ``{` `    ``while` `(node != ``null``)` `    ``{` `      ``Console.Write(node.data + ``" "``);` `      ``node = node.next;` `    ``}` `  ``}`   `}`   `// This code is contributed by Kushagra Keserwani`   `class` `HelloWorld {`   `  ``static` `void` `Main() {` `    ``DoublyLinkedList list = ``new` `DoublyLinkedList();`   `    ``/* Let us create a k sorted doubly linked list to test the` `             ``functions Created doubly linked list will be 3<->6<->2<->12<->56<->8 ` `           ``*/` `    ``Node head = list.push(8);` `    ``head = list.push(56);` `    ``head = list.push(12);` `    ``head = list.push(2);` `    ``head = list.push(6);` `    ``head = list.push(3);`   `    ``int` `k = 2;`   `    ``Console.WriteLine(``"Original Doubly linked list:"``);` `    ``list.printList(head);`   `    ``Node sortedDLL = list.sortAKSortedDLL(head, k);` `    ``Console.WriteLine(``""``);` `    ``Console.WriteLine(``"Doubly Linked List after sorting:"``);` `    ``list.printList(sortedDLL);` `  ``}` `}`   `// The code is contributed by Nidhi goel.`

## Javascript

 `// javascript implementation to sort a k sorted doubly` `// linked list`   `// a node of the doubly linked list` `class Node {` `    `  `    ``constructor(val){` `        ``this``.data = val;` `        ``this``.next = ``null``;` `        ``this``.prev = ``null``;` `    ``}` `}`     `// function to sort a k sorted doubly linked list` `function` `sortAKSortedDLL(head, k)` `{` `    ``// if list is empty` `    ``if` `(head == ``null``)` `        ``return` `head;`   `    ``// priority_queue 'pq' implemented as min heap with the` `    ``// help of 'compare' function` `    ``let pq = [];`   `    ``let newHead = ``null``;` `    ``let last = ``null``;`   `    ``// Create a Min Heap of first (k+1) elements from` `    ``// input doubly linked list` `    ``for` `(let i = 0; head != ``null` `&& i <= k; i++) {` `        ``// push the node on to 'pq'` `        ``pq.push(head);` `        ``pq.sort(``function``(a, b){` `            ``return` `a.data - b.data;` `        ``});` `        ``// move to the next node` `        ``head = head.next;` `    ``}`   `    ``// loop till there are elements in 'pq'` `    ``while` `(pq.length > 0) {`   `        ``// place root or top of 'pq' at the end of the` `        ``// result sorted list so far having the first node` `        ``// pointed to by 'newHead'` `        ``// and adjust the required links` `        ``if` `(newHead == ``null``) {` `            ``newHead = pq;` `            ``newHead.prev = ``null``;`   `            ``// 'last' points to the last node` `            ``// of the result sorted list so far` `            ``last = newHead;` `        ``}`   `        ``else` `{` `            ``last.next = pq;` `            ``pq.prev = last;` `            ``last = pq;` `        ``}`   `        ``// remove element from 'pq'` `        ``pq.shift();`   `        ``// if there are more nodes left in the input list` `        ``if` `(head != ``null``) {` `            ``// push the node on to 'pq'` `            ``pq.push(head);` `            ``pq.sort(``function` `(a, b){` `                ``return` `a.data - b.data;` `            ``});`   `            ``// move to the next node` `            ``head = head.next;` `        ``}` `    ``}`   `    ``// making 'next' of last node point to NULL` `    ``last.next = ``null``;`   `    ``// new head of the required sorted DLL` `    ``return` `newHead;` `}`   `// Function to insert a node at the beginning` `// of the Doubly Linked List` `function` `push(head, new_data)` `{` `    ``// allocate node` `    ``let new_node = ``new` `Node(new_data);`   `    ``// put in the data` `    ``new_node.data = new_data;`   `    ``// since we are adding at the beginning,` `    ``// prev is always NULL` `    ``new_node.prev = ``null``;`   `    ``// link the old list of the new node` `    ``new_node.next = head;`   `    ``// change prev of head node to new node` `    ``if` `(head != ``null``)` `        ``head.prev = new_node;`   `    ``// move the head to point to the new node` `    ``head = new_node;` `    `  `    ``return` `head;` `}`   `// Function to print nodes in a given doubly linked list` `function` `printList(head)` `{` `    ``// if list is empty` `    ``if` `(head == ``null``)` `        ``console.log(``"Doubly Linked list empty\n"``);` `    `  `    ``let temp = ``""``;` `    ``while` `(head != ``null``) {` `        ``temp = temp + head.data + ``" "``;` `        ``// console.log(head.data + " ");` `        ``head = head.next;` `    ``}` `    ``console.log(temp);` `}`   `// Driver program to test above` `let head = ``null``;`   `// Create the doubly linked list:` `// 3<->6<->2<->12<->56<->8` `head = push(head, 8);` `head = push(head, 56);` `head = push(head, 12);` `head = push(head, 2);` `head = push(head, 6);` `head = push(head, 3);`   `let k = 2;`   `console.log(``"Original Doubly linked list:"``);` `printList(head);`   `// sort the biotonic DLL` `head = sortAKSortedDLL(head, k);`   `console.log(``"\nDoubly Linked List after sorting:"``);` `printList(head);`     `// the code is contributed by Nidhi goel.`

Output

```Original Doubly linked list:
3 6 2 12 56 8