Merge K sorted Doubly Linked List in Sorted Order Last Updated : 17 Jan, 2023 Comments Improve Suggest changes Like Article Like Report 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 16Input: 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: First merge two doubly linked list in sorted orderThen merge this list with another list in sorted orderDo the same thing until all list are not mergedKeep 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 if head(A) < head(B) then append head(A) to C drop the head of A else append head(B) to C drop the head of B // By now, either A or B is empty // It remains to empty the other input list while A is not empty do append head(A) to C drop the head of A while B is not empty do append head(B) to C drop the head of B return C Below is the implementation of the above approach: C++ // C++ program to merge K sorted doubly // linked list in sorted order #include <bits/stdc++.h> 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[0], 1); append(&head[0], 5); append(&head[0], 9); // Create second doubly linked List // List2 -> 2 <=> 3 <=> 7 <=> 12 append(&head[1], 2); append(&head[1], 3); append(&head[1], 7); append(&head[1], 12); // Create third doubly linked List // List3 -> 8 <=> 11 <=> 13 <=> 18 append(&head[2], 8); append(&head[2], 11); append(&head[2], 13); 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); 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[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 AnkitRai01 JavaScript <script> // javascript program to merge K sorted doubly // linked list in sorted order // A linked list node class Node { constructor(){ this.data = 0; this.next = null; this.prev = null; } } // Given a reference (pointer to pointer) to the head // Of a DLL and an int, appends a new node at the end function append( head_ref , new_data) { // Allocate node new_node = new 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 function printList( node) { last; // Run while loop unless node becomes null while (node != null) { document.write(node.data + " "); last = node; node = node.next; } } // Function to merge two // sorted doubly linked lists function mergeList( p, q) { 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 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 function mergeAllList( head , k) { finalList = null; for (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 var k = 3; head = Array(k).fill(null); // Loop to initialize all the lists to empty for (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 finalList = mergeAllList(head, k); // Print final sorted list printList(finalList); // This code is contributed by umadevi9616 </script> Output: 1 2 3 5 7 8 9 11 12 13 18 Time Complexity: O(N*k)Auxiliary Space: O(1) Comment More infoAdvertise with us Next Article Merge a linked list into another linked list at alternate positions M MohammadMudassir Follow Improve Article Tags : Linked List Sorting DSA doubly linked list Practice Tags : Linked ListSorting Similar Reads Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge 14 min read Merge sort in different languagesC Program for Merge SortMerge Sort is a comparison-based sorting algorithm that works by dividing the input array into two halves, then calling itself for these two halves, and finally it merges the two sorted halves. In this article, we will learn how to implement merge sort in C language.What is Merge Sort Algorithm?Merg 3 min read C++ Program For Merge SortMerge Sort is a comparison-based sorting algorithm that uses divide and conquer paradigm to sort the given dataset. It divides the dataset into two halves, calls itself for these two halves, and then it merges the two sorted halves.In this article, we will learn how to implement merge sort in a C++ 4 min read Java Program for Merge SortMerge Sort is a divide-and-conquer algorithm. It divides the input array into two halves, calls itself the two halves, and then merges the two sorted halves. The merge() function is used for merging two halves. The merge(arr, l, m, r) is a key process that assumes that arr[l..m] and arr[m+1..r] are 3 min read Merge Sort in PythonMerge Sort is a Divide and Conquer algorithm. It divides input array in two halves, calls itself for the two halves and then merges the two sorted halves. The merge() function is used for merging two halves. The merge(arr, l, m, r) is key process that assumes that arr[l..m] and arr[m+1..r] are sorte 4 min read Merge Sort using Multi-threadingMerge Sort is a popular sorting technique which divides an array or list into two halves and then start merging them when sufficient depth is reached. Time complexity of merge sort is O(nlogn).Threads are lightweight processes and threads shares with other threads their code section, data section an 14 min read Variations of Merge Sort3-way Merge SortMerge Sort is a divide-and-conquer algorithm that recursively splits an array into two halves, sorts each half, and then merges them. A variation of this is 3-way Merge Sort, where instead of splitting the array into two parts, we divide it into three equal parts. In traditional Merge Sort, the arra 13 min read Iterative Merge SortGiven an array of size n, the task is to sort the given array using iterative merge sort.Examples:Input: arr[] = [4, 1, 3, 9, 7]Output: [1, 3, 4, 7, 9]Explanation: The output array is sorted.Input: arr[] = [1, 3 , 2]Output: [1, 2, 3]Explanation: The output array is sorted.You can refer to Merge Sort 9 min read In-Place Merge SortImplement Merge Sort i.e. standard implementation keeping the sorting algorithm as in-place. In-place means it does not occupy extra memory for merge operation as in the standard case. Examples: Input: arr[] = {2, 3, 4, 1} Output: 1 2 3 4 Input: arr[] = {56, 2, 45} Output: 2 45 56 Approach 1: Mainta 15+ min read In-Place Merge Sort | Set 2Given an array A[] of size N, the task is to sort the array in increasing order using In-Place Merge Sort. Examples: Input: A = {5, 6, 3, 2, 1, 6, 7}Output: {1, 2, 3, 5, 6, 6, 7} Input: A = {2, 3, 4, 1}Output: {1, 2, 3, 4} Approach: The idea is to use the inplace_merge() function to merge the sorted 7 min read Merge Sort with O(1) extra space merge and O(n log n) time [Unsigned Integers Only]We have discussed Merge sort. How to modify the algorithm so that merge works in O(1) extra space and algorithm still works in O(n Log n) time. We may assume that the input values are integers only. Examples: Input : 5 4 3 2 1 Output : 1 2 3 4 5 Input : 999 612 589 856 56 945 243 Output : 56 243 589 10 min read Merge Sort in Linked ListMerge Sort for Linked ListsGiven a singly linked list, The task is to sort the linked list in non-decreasing order using merge sort.Examples: Input: 40 -> 20 -> 60 -> 10 -> 50 -> 30 -> NULLOutput: 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> NULLInput: 9 -> 5 -> 2 -> 8 -> NULLOutput: 2 - 12 min read Merge Sort for Doubly Linked ListGiven a doubly linked list, The task is to sort the doubly linked list in non-decreasing order using merge sort.Examples:Input: 10 <-> 8 <-> 4 <-> 2Output: 2 <-> 4 <-> 8 <-> 10Input: 5 <-> 3 <-> 2Output: 2 <-> 3 <-> 5 Note: Merge sort for a 13 min read Iterative Merge Sort for Linked ListGiven a singly linked list of integers, the task is to sort it using iterative merge sort.Examples:Input: 40 -> 20 -> 60 -> 10 -> 50 -> 30 -> NULLOutput: 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> NULLInput: 9 -> 5 -> 2 -> 8 -> NULLOutput: 2 -> 5 -> 8 - 13 min read Merge two sorted lists (in-place)Given two sorted linked lists consisting of n and m nodes respectively. The task is to merge both of the lists and return the head of the merged list.Example:Input: Output: Input: Output: Approach:The idea is to iteratively merge two sorted linked lists using a dummy node to simplify the process. A 9 min read Merge K sorted Doubly Linked List in Sorted OrderGiven 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 Li 15+ min read Merge a linked list into another linked list at alternate positionsGiven two singly linked lists, The task is to insert nodes of the second list into the first list at alternate positions of the first list and leave the remaining nodes of the second list if it is longer.Example:Input: head1: 1->2->3 , head2: 4->5->6->7->8Output: head1: 1->4- 8 min read Find a permutation that causes worst case of Merge Sort Given a set of elements, find which permutation of these elements would result in worst case of Merge Sort.Asymptotically, merge sort always takes O(n Log n) time, but the cases that require more comparisons generally take more time in practice. We basically need to find a permutation of input eleme 12 min read How to make Mergesort to perform O(n) comparisons in best case? As we know, Mergesort is a divide and conquer algorithm that splits the array to halves recursively until it reaches an array of the size of 1, and after that it merges sorted subarrays until the original array is fully sorted. Typical implementation of merge sort works in O(n Log n) time in all thr 3 min read Concurrent Merge Sort in Shared Memory Given a number 'n' and a n numbers, sort the numbers using Concurrent Merge Sort. (Hint: Try to use shmget, shmat system calls).Part1: The algorithm (HOW?) Recursively make two child processes, one for the left half, one of the right half. If the number of elements in the array for a process is less 10 min read Visualization of Merge SortSorting Algorithm Visualization : Merge SortThe human brain can easily process visuals instead of long codes to understand the algorithms. In this article, a program that program visualizes the Merge sort Algorithm has been implemented. The GUI(Graphical User Interface) is implemented using pygame package in python. Approach: An array of rand 3 min read Merge Sort Visualization in JavaScriptGUI(Graphical User Interface) helps users with better understanding programs. In this article, we will visualize Merge Sort using JavaScript. We will see how the arrays are divided and merged after sorting to get the final sorted array. Refer: Merge SortCanvas in HTMLAsynchronous Function in JavaSc 4 min read Visualize Merge sort Using Tkinter in PythonPrerequisites: Python GUI – tkinter In this article, we will create a GUI application that will help us to visualize the algorithm of merge sort using Tkinter in Python. Merge Sort is a popular sorting algorithm. It has a time complexity of N(logN) which is faster than other sorting algorithms like 5 min read Visualization of Merge sort using MatplotlibPrerequisites: Introduction to Matplotlib, Merge Sort Visualizing algorithms makes it easier to understand them by analyzing and comparing the number of operations that took place to compare and swap the elements. For this we will use matplotlib, to plot bar graphs to represent the elements of the a 3 min read 3D Visualisation of Merge Sort using MatplotlibVisualizing algorithms makes it easier to understand them by analyzing and comparing the number of operations that took place to compare and swap the elements. 3D visualization of algorithms is less common, for this we will use matplotlib to plot bar graphs and animate them to represent the elements 3 min read Some problems on Merge SortCount Inversions of an ArrayGiven an integer array arr[] of size n, find the inversion count in the array. Two array elements arr[i] and arr[j] form an inversion if arr[i] > arr[j] and i < j.Note: Inversion Count for an array indicates that how far (or close) the array is from being sorted. If the array is already sorted 15+ min read Count of smaller elements on right side of each element in an Array using Merge sortGiven an array arr[] of N integers, the task is to count the number of smaller elements on the right side for each of the element in the array Examples: Input: arr[] = {6, 3, 7, 2} Output: 2, 1, 1, 0 Explanation: Smaller elements after 6 = 2 [3, 2] Smaller elements after 3 = 1 [2] Smaller elements a 12 min read Sort a nearly sorted (or K sorted) arrayGiven an array arr[] and a number k . The array is sorted in a way that every element is at max k distance away from it sorted position. It means if we completely sort the array, then the index of the element can go from i - k to i + k where i is index in the given array. Our task is to completely s 6 min read Median of two Sorted Arrays of Different SizesGiven two sorted arrays, a[] and b[], the task is to find the median of these sorted arrays. Assume that the two sorted arrays are merged and then median is selected from the combined array.This is an extension of Median of two sorted arrays of equal size problem. Here we handle arrays of unequal si 15+ min read Merge k Sorted ArraysGiven K sorted arrays, merge them and print the sorted output.Examples:Input: K = 3, arr = { {1, 3, 5, 7}, {2, 4, 6, 8}, {0, 9, 10, 11}}Output: 0 1 2 3 4 5 6 7 8 9 10 11 Input: k = 4, arr = { {1}, {2, 4}, {3, 7, 9, 11}, {13} }Output: 1 2 3 4 7 9 11 13Table of ContentNaive - Concatenate all and SortU 15+ min read Merge K sorted arrays of different sizes | ( Divide and Conquer Approach )Given k sorted arrays of different length, merge them into a single array such that the merged array is also sorted.Examples: Input : {{3, 13}, {8, 10, 11} {9, 15}} Output : {3, 8, 9, 10, 11, 13, 15} Input : {{1, 5}, {2, 3, 4}} Output : {1, 2, 3, 4, 5} Let S be the total number of elements in all th 8 min read Merge K sorted linked listsGiven k sorted linked lists of different sizes, the task is to merge them all maintaining their sorted order.Examples: Input: Output: Merged lists in a sorted order where every element is greater than the previous element.Input: Output: Merged lists in a sorted order where every element is greater t 15+ min read Union and Intersection of two Linked List using Merge SortGiven two singly Linked Lists, create union and intersection lists that contain the union and intersection of the elements present in the given lists. Each of the two lists contains distinct node values.Note: The order of elements in output lists doesn't matter.Examples:Input: head1: 10 -> 15 - 15+ min read Sorting by combining Insertion Sort and Merge Sort algorithmsInsertion sort: The array is virtually split into a sorted and an unsorted part. Values from the unsorted part are picked and placed at the correct position in the sorted part.Advantages: Following are the advantages of insertion sort: If the size of the list to be sorted is small, insertion sort ru 2 min read Find array with k number of merge sort callsGiven two numbers n and k, find an array containing values in [1, n] and requires exactly k calls of recursive merge sort function. Examples: Input : n = 3 k = 3 Output : a[] = {2, 1, 3} Explanation: Here, a[] = {2, 1, 3} First of all, mergesort(0, 3) will be called, which then sets mid = 1 and call 6 min read Difference of two Linked Lists using Merge sortGiven two Linked List, the task is to create a Linked List to store the difference of Linked List 1 with Linked List 2, i.e. the elements present in List 1 but not in List 2.Examples: Input: List1: 10 -> 15 -> 4 ->20, List2: 8 -> 4 -> 2 -> 10 Output: 15 -> 20 Explanation: In the 14 min read Like