 Open in App
Not now

# Sort a k sorted doubly linked list

• Difficulty Level : Hard
• Last Updated : 10 Jan, 2023

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)`

Output

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