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<bits/stdc++.h>using namespace std;// a node of the doubly linked liststruct Node { int data; struct Node* next; struct Node* prev;};// function to sort a k sorted doubly linked liststruct 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 Listvoid 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 listvoid 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 aboveint 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 doublyimport 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 codepublic 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 = Noneclass 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 Listdef 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 listdef 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<->8push(8)push(56)push(12)push(2)push(6)push(3)k = 2print("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 listsusing 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
<script>// javascript implementation to sort a k sorted doublyclass DoublyLinkedList { var head; class Node { constructor(val) { this.data = val; this.prev = null; this.next = null; } } // function to sort a k sorted doubly linked list // Using Insertion Sort // Time Complexity: O(n*k) // Space Complexity: O(1) function sortAKSortedDLL(head , k) { if (head == null || head.next == null) return head; // perform on all the nodes in list for (i = head.next; i != null; i = i.next) { var 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 var temp = j.prev.prev; var temp2 = j.prev; var 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 */ function push(new_data) { /* allocate node */var 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 */ function printList(node) { while (node != null) { document.write(node.data + " "); 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); var k = 2; document.write("Original Doubly linked list:<br/>"); printList(head);var sortedDLL = sortAKSortedDLL(head, k); document.write(""); document.write("<br/>Doubly Linked List after sorting:<br/>"); printList(sortedDLL);// This code contributed by aashish1995</script> |
Output
Original Doubly linked list: 3 6 2 12 56 8 Doubly Linked List after sorting: 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 <bits/stdc++.h>using namespace std;// a node of the doubly linked liststruct Node { int data; struct Node* next; struct Node* prev;};// 'compare' function used to build up the// priority queuestruct compare { bool operator()(struct Node* p1, struct Node* p2) { return p1->data > p2->data; }};// function to sort a k sorted doubly linked liststruct 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<Node*, vector<Node*>, 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 Listvoid 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 listvoid 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 aboveint 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 doublyimport 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<Node> { 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<Node> pq = new PriorityQueue<Node>(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 listimport heapqhead = None# a node of the doubly linked listclass Node: def __init__(self, data): self.data = data self.next = None self.prev = None# function to sort a k sorted doubly linked listdef 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 Listdef 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 listdef 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 codeif __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 doublyclass 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<Node> pq = new List<Node>(); 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[0]; newHead.prev = null; // 'last' points to the last node // of the result sorted list so far last = newHead; } else { last.next = pq[0]; pq[0].prev = last; last = pq[0]; } // 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 Keserwaniclass 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 listclass Node { constructor(val){ this.data = val; this.next = null; this.prev = null; }}// function to sort a k sorted doubly linked listfunction 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[0]; newHead.prev = null; // 'last' points to the last node // of the result sorted list so far last = newHead; } else { last.next = pq[0]; pq[0].prev = last; last = pq[0]; } // 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 Listfunction 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 listfunction 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 abovelet head = null;// Create the doubly linked list:// 3<->6<->2<->12<->56<->8head = 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 DLLhead = 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 Doubly linked list after sorting: 2 3 6 8 12 56
Time Complexity: O(n*log k)
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 write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Login to comment...