Find smallest range containing elements from k lists

01 Jul, 2022
Given k sorted lists of integers of size n each, find the smallest range that includes at least one element from each of the k lists. If more than one smallest range is found, print any one of them.
Example: 
Input: K = 3
arr1[] : [4, 7, 9, 12, 15]
arr2[] : [0, 8, 10, 14, 20]
arr3[] : [6, 12, 16, 30, 50]
Output:
The smallest range is [6 8]

Explanation: Smallest range is formed by 
number 7 from the first list, 8 from second
list and 6 from the third list.

Input: k = 3
arr1[] : [4, 7]
arr2[] : [1, 2]
arr3[] : [20, 40]
Output:
The smallest range is [2 20]

Explanation:The range [2, 20] contains 2, 4, 7, 20
which contains element from all the three arrays.
Naive Approach: Given K sorted list, find a range where there is at least one element from every list. The idea to solve the problem is very simple, keep k pointers which will constitute the elements in the range, by taking the min and max of the k elements the range can be formed. Initially, all the pointers will point to the start of all the k arrays. Store the range max to min. If the range has to be minimized then either the minimum value has to be increased or the maximum value has to be decreased. To decrease the maximum value we have to move our pointer of current maximum to the left and since we are currently at 0 the index of every list so we can’t move our pointer to left, hence we can’t decrease the current max. So, the only possible option to get a better range is to increase the current minimum. To continue increasing the minimum value, increase the pointer of the list containing the minimum value and update the range until one of the lists exhausts.
Algorithm: Create an extra space ptr of length k to store the pointers and a variable minrange initialized to a maximum value.Initially the index of every list is 0, therefore initialize every element of ptr[0..k] to 0, the array ptr will store the index of the elements in the range.Repeat the following steps until at least one list exhausts: Now find the minimum and maximum value among the current elements of all the list pointed by the ptr[0...k] array.Now update the minrange if current (max-min) is less than minrange.increment the pointer pointing to current minimum element.
Create an extra space ptr of length k to store the pointers and a variable minrange initialized to a maximum value.Initially the index of every list is 0, therefore initialize every element of ptr[0..k] to 0, the array ptr will store the index of the elements in the range.Repeat the following steps until at least one list exhausts: Now find the minimum and maximum value among the current elements of all the list pointed by the ptr[0...k] array.Now update the minrange if current (max-min) is less than minrange.increment the pointer pointing to current minimum element.
Create an extra space ptr of length k to store the pointers and a variable minrange initialized to a maximum value.
Initially the index of every list is 0, therefore initialize every element of ptr[0..k] to 0, the array ptr will store the index of the elements in the range.
Repeat the following steps until at least one list exhausts: Now find the minimum and maximum value among the current elements of all the list pointed by the ptr[0...k] array.Now update the minrange if current (max-min) is less than minrange.increment the pointer pointing to current minimum element.
Now find the minimum and maximum value among the current elements of all the list pointed by the ptr[0...k] array.Now update the minrange if current (max-min) is less than minrange.increment the pointer pointing to current minimum element.
Now find the minimum and maximum value among the current elements of all the list pointed by the ptr[0...k] array.
Now update the minrange if current (max-min) is less than minrange.
increment the pointer pointing to current minimum element.
Implementation:
C++
Java
Python
C#
Javascript
// C++ program to finds out smallest range that includes// elements from each of the given sorted lists.#include <bits/stdc++.h> using namespace std; #define N 5 // array for storing the current index of list iint ptr[501]; // This function takes an k sorted lists in the form of// 2D array as an argument. It finds out smallest range// that includes elements from each of the k lists.void findSmallestRange(int arr[][N], int n, int k){    int i, minval, maxval, minrange, minel, maxel, flag, minind;     // initializing to 0 index;    for (i = 0; i <= k; i++)        ptr[i] = 0;     minrange = INT_MAX;     while (1) {        // for maintaining the index of list containing the minimum element        minind = -1;        minval = INT_MAX;        maxval = INT_MIN;        flag = 0;         // iterating over all the list        for (i = 0; i < k; i++) {            // if every element of list[i] is traversed then break the loop            if (ptr[i] == n) {                flag = 1;                break;            }            // find minimum value among all the list elements pointing by the ptr[] array            if (ptr[i] < n && arr[i][ptr[i]] < minval) {                minind = i; // update the index of the list                minval = arr[i][ptr[i]];            }            // find maximum value among all the list elements pointing by the ptr[] array            if (ptr[i] < n && arr[i][ptr[i]] > maxval) {                maxval = arr[i][ptr[i]];            }        }         // if any list exhaust we will not get any better answer, so break the while loop        if (flag)            break;         ptr[minind]++;         // updating the minrange        if ((maxval - minval) < minrange) {            minel = minval;            maxel = maxval;            minrange = maxel - minel;        }    }     printf("The smallest range is [%d, %d]\n", minel, maxel);} // Driver program to test above functionint main(){    int arr[][N] = {        { 4, 7, 9, 12, 15 },        { 0, 8, 10, 14, 20 },        { 6, 12, 16, 30, 50 }    };     int k = sizeof(arr) / sizeof(arr[0]);     findSmallestRange(arr, N, k);     return 0;}// This code is contributed by Aditya Krishna Namdeo
// Java program to finds out smallest range that includes// elements from each of the given sorted lists.class GFG {     static final int N = 5;     // array for storing the current index of list i    static int ptr[] = new int[501];     // This function takes an k sorted lists in the form of    // 2D array as an argument. It finds out smallest range    // that includes elements from each of the k lists.    static void findSmallestRange(int arr[][], int n, int k)    {        int i, minval, maxval, minrange, minel = 0, maxel = 0, flag, minind;         // initializing to 0 index;        for (i = 0; i <= k; i++) {            ptr[i] = 0;        }         minrange = Integer.MAX_VALUE;         while (true) {            // for maintaining the index of list containing the minimum element            minind = -1;            minval = Integer.MAX_VALUE;            maxval = Integer.MIN_VALUE;            flag = 0;             // iterating over all the list            for (i = 0; i < k; i++) {                // if every element of list[i] is traversed then break the loop                if (ptr[i] == n) {                    flag = 1;                    break;                }                // find minimum value among all the list elements pointing by the ptr[] array                if (ptr[i] < n && arr[i][ptr[i]] < minval) {                    minind = i; // update the index of the list                    minval = arr[i][ptr[i]];                }                // find maximum value among all the list elements pointing by the ptr[] array                if (ptr[i] < n && arr[i][ptr[i]] > maxval) {                    maxval = arr[i][ptr[i]];                }            }             // if any list exhaust we will not get any better answer, so break the while loop            if (flag == 1) {                break;            }             ptr[minind]++;             // updating the minrange            if ((maxval - minval) < minrange) {                minel = minval;                maxel = maxval;                minrange = maxel - minel;            }        }        System.out.printf("The smallest range is [%d, %d]\n", minel, maxel);    }     // Driver program to test above function    public static void main(String[] args)    {         int arr[][] = {            { 4, 7, 9, 12, 15 },            { 0, 8, 10, 14, 20 },            { 6, 12, 16, 30, 50 }        };         int k = arr.length;         findSmallestRange(arr, N, k);    }}// this code contributed by Rajput-Ji
# Python3 program to finds out# smallest range that includes# elements from each of the# given sorted lists. N = 5 # array for storing the# current index of list iptr = [0 for i in range(501)] # This function takes an k sorted# lists in the form of 2D array as# an argument. It finds out smallest# range that includes elements from# each of the k lists.def findSmallestRange(arr, n, k):     i, minval, maxval, minrange, minel, maxel, flag, minind = 0, 0, 0, 0, 0, 0, 0, 0             # initializing to 0 index    for i in range(k + 1):        ptr[i] = 0     minrange = 10**9             while(1):                        # for maintaining the index of list            # containing the minimum element        minind = -1        minval = 10**9        maxval = -10**9        flag = 0         # iterating over all the list        for i in range(k):                             # if every element of list[i] is                # traversed then break the loop            if(ptr[i] == n):                flag = 1                   break             # find minimum value among all the list            # elements pointing by the ptr[] array            if(ptr[i] < n and arr[i][ptr[i]] < minval):                minind = i # update the index of the list                minval = arr[i][ptr[i]]                         # find maximum value among all the            # list elements pointing by the ptr[] array            if(ptr[i] < n and arr[i][ptr[i]] > maxval):                maxval = arr[i][ptr[i]]                               # if any list exhaust we will        # not get any better answer,        # so break the while loop        if(flag):            break         ptr[minind] += 1         # updating the minrange        if((maxval-minval) < minrange):            minel = minval            maxel = maxval            minrange = maxel - minel         print("The smallest range is [", minel, maxel, "]") # Driver codearr = [    [4, 7, 9, 12, 15],    [0, 8, 10, 14, 20],    [6, 12, 16, 30, 50]    ] k = len(arr) findSmallestRange(arr, N, k) # This code is contributed by mohit kumar
// C# program to finds out smallest// range that includes elements from// each of the given sorted lists.using System; class GFG {     static int N = 5;     // array for storing the current index of list i    static int[] ptr = new int[501];     // This function takes an k sorted    // lists in the form of 2D array as    // an argument. It finds out smallest range    // that includes elements from each of the k lists.    static void findSmallestRange(int[, ] arr,                                  int n, int k)    {        int i, minval, maxval, minrange,            minel = 0, maxel = 0, flag, minind;         // initializing to 0 index;        for (i = 0; i <= k; i++) {            ptr[i] = 0;        }         minrange = int.MaxValue;         while (true) {            // for maintaining the index of            // list containing the minimum element            minind = -1;            minval = int.MaxValue;            maxval = int.MinValue;            flag = 0;             // iterating over all the list            for (i = 0; i < k; i++) {                // if every element of list[i]                // is traversed then break the loop                if (ptr[i] == n) {                    flag = 1;                    break;                }                 // find minimum value among all the                // list elements pointing by the ptr[] array                if (ptr[i] < n && arr[i, ptr[i]] < minval) {                    minind = i; // update the index of the list                    minval = arr[i, ptr[i]];                }                 // find maximum value among all the                // list elements pointing by the ptr[] array                if (ptr[i] < n && arr[i, ptr[i]] > maxval) {                    maxval = arr[i, ptr[i]];                }            }             // if any list exhaust we will            // not get any better answer,            // so break the while loop            if (flag == 1) {                break;            }             ptr[minind]++;             // updating the minrange            if ((maxval - minval) < minrange) {                minel = minval;                maxel = maxval;                minrange = maxel - minel;            }        }        Console.WriteLine("The smallest range is"                              + "[{0}, {1}]\n",                          minel, maxel);    }     // Driver code    public static void Main(String[] args)    {         int[, ] arr = {            { 4, 7, 9, 12, 15 },            { 0, 8, 10, 14, 20 },            { 6, 12, 16, 30, 50 }        };         int k = arr.GetLength(0);         findSmallestRange(arr, N, k);    }} // This code has been contributed by 29AjayKumar
<script>  // Javascript program to finds out smallest range that includes// elements from each of the given sorted lists.let N = 5; // array for storing the current index of list ilet ptr=new Array(501); // This function takes an k sorted lists in the form of    // 2D array as an argument. It finds out smallest range    // that includes elements from each of the k lists.function findSmallestRange(arr,n,k){    let i, minval, maxval, minrange, minel = 0, maxel = 0, flag, minind;           // initializing to 0 index;        for (i = 0; i <= k; i++) {            ptr[i] = 0;        }           minrange = Number.MAX_VALUE;           while (true) {            // for maintaining the index of list containing the minimum element            minind = -1;            minval = Number.MAX_VALUE;            maxval = Number.MIN_VALUE;            flag = 0;               // iterating over all the list            for (i = 0; i < k; i++) {                // if every element of list[i] is traversed then break the loop                if (ptr[i] == n) {                    flag = 1;                    break;                }                // find minimum value among all the list elements pointing by the ptr[] array                if (ptr[i] < n && arr[i][ptr[i]] < minval) {                    minind = i; // update the index of the list                    minval = arr[i][ptr[i]];                }                // find maximum value among all the list elements pointing by the ptr[] array                if (ptr[i] < n && arr[i][ptr[i]] > maxval) {                    maxval = arr[i][ptr[i]];                }            }               // if any list exhaust we will not get any better answer, so break the while loop            if (flag == 1) {                break;            }               ptr[minind]++;               // updating the minrange            if ((maxval - minval) < minrange) {                minel = minval;                maxel = maxval;                minrange = maxel - minel;            }        }        document.write("The smallest range is ["+minel+", "+maxel+"]<br>");} // Driver program to test above functionlet arr = [    [4, 7, 9, 12, 15],    [0, 8, 10, 14, 20],    [6, 12, 16, 30, 50]    ]let k = arr.length;findSmallestRange(arr, N, k);  // This code is contributed by unknown2108 </script>
The smallest range is [6, 8]
Complexity Analysis: Time complexity : O(n * k2), to find the maximum and minimum in an array of length k the time required is O(k), and to traverse all the k arrays of length n (in worst case), the time complexity is O(n*k), then the total time complexity is O(n*k2).Space complexity: O(k), an extra array is required of length k so the space complexity is O(k)
Time complexity : O(n * k2), to find the maximum and minimum in an array of length k the time required is O(k), and to traverse all the k arrays of length n (in worst case), the time complexity is O(n*k), then the total time complexity is O(n*k2).
Space complexity: O(k), an extra array is required of length k so the space complexity is O(k)
Efficient approach: The approach remains the same but the time complexity can be reduced by using min-heap or priority queue. Min heap can be used to find the maximum and minimum value in logarithmic time or log k time instead of linear time. Rest of the approach remains the same. 
Algorithm: create a Min heap to store k elements, one from each array and a variable minrange initialized to a maximum value and also keep a variable max to store the maximum integer.Initially put the first element of each element from each list and store the maximum value in max.Repeat the following steps until at least one list exhausts : To find the minimum value or min, use the top or root of the Min heap which is the minimum element.Now update the minrange if current (max-min) is less than minrange.remove the top or root element from priority queue and insert the next element from the list which contains the min element and update the max with the new element inserted.
create a Min heap to store k elements, one from each array and a variable minrange initialized to a maximum value and also keep a variable max to store the maximum integer.Initially put the first element of each element from each list and store the maximum value in max.Repeat the following steps until at least one list exhausts : To find the minimum value or min, use the top or root of the Min heap which is the minimum element.Now update the minrange if current (max-min) is less than minrange.remove the top or root element from priority queue and insert the next element from the list which contains the min element and update the max with the new element inserted.
create a Min heap to store k elements, one from each array and a variable minrange initialized to a maximum value and also keep a variable max to store the maximum integer.
Initially put the first element of each element from each list and store the maximum value in max.
Repeat the following steps until at least one list exhausts : To find the minimum value or min, use the top or root of the Min heap which is the minimum element.Now update the minrange if current (max-min) is less than minrange.remove the top or root element from priority queue and insert the next element from the list which contains the min element and update the max with the new element inserted.
To find the minimum value or min, use the top or root of the Min heap which is the minimum element.Now update the minrange if current (max-min) is less than minrange.remove the top or root element from priority queue and insert the next element from the list which contains the min element and update the max with the new element inserted.
To find the minimum value or min, use the top or root of the Min heap which is the minimum element.
Now update the minrange if current (max-min) is less than minrange.
remove the top or root element from priority queue and insert the next element from the list which contains the min element and update the max with the new element inserted.
Implementation:
C++
Java
C#
Javascript
// C++ program to finds out smallest range that includes// elements from each of the given sorted lists.#include <bits/stdc++.h>using namespace std; #define N 5 // A min heap nodestruct MinHeapNode {    // The element to be stored    int element;     // index of the list from which the element is taken    int i;     // index of the next element to be picked from list    int j;}; // Prototype of a utility function to swap two min heap nodesvoid swap(MinHeapNode* x, MinHeapNode* y); // A class for Min Heapclass MinHeap {     // pointer to array of elements in heap    MinHeapNode* harr;     // size of min heap    int heap_size; public:    // Constructor: creates a min heap of given size    MinHeap(MinHeapNode a[], int size);     // to heapify a subtree with root at given index    void MinHeapify(int);     // to get index of left child of node at index i    int left(int i) { return (2 * i + 1); }     // to get index of right child of node at index i    int right(int i) { return (2 * i + 2); }     // to get the root    MinHeapNode getMin() { return harr[0]; }     // to replace root with new node x and heapify() new root    void replaceMin(MinHeapNode x)    {        harr[0] = x;        MinHeapify(0);    }}; // Constructor: Builds a heap from a// given array a[] of given sizeMinHeap::MinHeap(MinHeapNode a[], int size){    heap_size = size;    harr = a; // store address of array    int i = (heap_size - 1) / 2;    while (i >= 0) {        MinHeapify(i);        i--;    }} // A recursive method to heapify a subtree with root at// given index. This method assumes that the subtrees// are already heapifiedvoid MinHeap::MinHeapify(int i){    int l = left(i);    int r = right(i);    int smallest = i;    if (l < heap_size && harr[l].element < harr[i].element)        smallest = l;    if (r < heap_size && harr[r].element < harr[smallest].element)        smallest = r;    if (smallest != i) {        swap(harr[i], harr[smallest]);        MinHeapify(smallest);    }} // This function takes an k sorted lists in the form of// 2D array as an argument. It finds out smallest range// that includes elements from each of the k lists.void findSmallestRange(int arr[][N], int k){    // Create a min heap with k heap nodes. Every heap node    // has first element of an list    int range = INT_MAX;    int min = INT_MAX, max = INT_MIN;    int start, end;     MinHeapNode* harr = new MinHeapNode[k];    for (int i = 0; i < k; i++) {        // Store the first element        harr[i].element = arr[i][0];         // index of list        harr[i].i = i;         // Index of next element to be stored        // from list        harr[i].j = 1;         // store max element        if (harr[i].element > max)            max = harr[i].element;    }     // Create the heap    MinHeap hp(harr, k);     // Now one by one get the minimum element from min    // heap and replace it with next element of its list    while (1) {        // Get the minimum element and store it in output        MinHeapNode root = hp.getMin();         // update min        min = hp.getMin().element;         // update range        if (range > max - min + 1) {            range = max - min + 1;            start = min;            end = max;        }         // Find the next element that will replace current        // root of heap. The next element belongs to same        // list as the current root.        if (root.j < N) {            root.element = arr[root.i][root.j];            root.j += 1;             // update max element            if (root.element > max)                max = root.element;        }         // break if we have reached end of any list        else            break;         // Replace root with next element of list        hp.replaceMin(root);    }     cout << "The smallest range is "         << "["         << start << " " << end << "]" << endl;    ;} // Driver program to test above functionsint main(){    int arr[][N] = {        { 4, 7, 9, 12, 15 },        { 0, 8, 10, 14, 20 },        { 6, 12, 16, 30, 50 }    };    int k = sizeof(arr) / sizeof(arr[0]);     findSmallestRange(arr, k);     return 0;}
// Java program to find out smallest// range that includes elements from// each of the given sorted lists.class GFG {     // A min heap node    static class Node {        // The element to be stored        int ele;         // index of the list from which        // the element is taken        int i;         // index of the next element        // to be picked from list        int j;         Node(int a, int b, int c)        {            this.ele = a;            this.i = b;            this.j = c;        }    }     // A class for Min Heap    static class MinHeap {        Node[] harr; // array of elements in heap        int size; // size of min heap         // Constructor: creates a min heap        // of given size        MinHeap(Node[] arr, int size)        {            this.harr = arr;            this.size = size;            int i = (size - 1) / 2;            while (i >= 0) {                MinHeapify(i);                i--;            }        }         // to get index of left child        // of node at index i        int left(int i)        {            return 2 * i + 1;        }         // to get index of right child        // of node at index i        int right(int i)        {            return 2 * i + 2;        }         // to heapify a subtree with        // root at given index        void MinHeapify(int i)        {            int l = left(i);            int r = right(i);            int small = i;            if (l < size && harr[l].ele < harr[i].ele)                small = l;            if (r < size && harr[r].ele < harr[small].ele)                small = r;            if (small != i) {                swap(small, i);                MinHeapify(small);            }        }         void swap(int i, int j)        {            Node temp = harr[i];            harr[i] = harr[j];            harr[j] = temp;        }         // to get the root        Node getMin()        {            return harr[0];        }         // to replace root with new node x        // and heapify() new root        void replaceMin(Node x)        {            harr[0] = x;            MinHeapify(0);        }    }     // This function takes an k sorted lists    // in the form of 2D array as an argument.    // It finds out smallest range that includes    // elements from each of the k lists.    static void findSmallestRange(int[][] arr, int k)    {        int range = Integer.MAX_VALUE;        int min = Integer.MAX_VALUE;        int max = Integer.MIN_VALUE;        int start = -1, end = -1;         int n = arr[0].length;         // Create a min heap with k heap nodes.        // Every heap node has first element of an list        Node[] arr1 = new Node[k];        for (int i = 0; i < k; i++) {            Node node = new Node(arr[i][0], i, 1);            arr1[i] = node;             // store max element            max = Math.max(max, node.ele);        }         // Create the heap        MinHeap mh = new MinHeap(arr1, k);         // Now one by one get the minimum element        // from min heap and replace it with        // next element of its list        while (true) {            // Get the minimum element and            // store it in output            Node root = mh.getMin();             // update min            min = root.ele;             // update range            if (range > max - min + 1) {                range = max - min + 1;                start = min;                end = max;            }             // Find the next element that will            // replace current root of heap.            // The next element belongs to same            // list as the current root.            if (root.j < n) {                root.ele = arr[root.i][root.j];                root.j++;                 // update max element                if (root.ele > max)                    max = root.ele;            }            // break if we have reached            // end of any list            else                break;             // Replace root with next element of list            mh.replaceMin(root);        }        System.out.print("The smallest range is [" + start + " " + end + "]");    }     // Driver Code    public static void main(String[] args)    {        int arr[][] = { { 4, 7, 9, 12, 15 },                        { 0, 8, 10, 14, 20 },                        { 6, 12, 16, 30, 50 } };         int k = arr.length;         findSmallestRange(arr, k);    }} // This code is contributed by nobody_cares
// C# program to find out smallest// range that includes elements from// each of the given sorted lists.using System;using System.Collections.Generic; class GFG {     // A min heap node    public class Node {        // The element to be stored        public int ele;         // index of the list from which        // the element is taken        public int i;         // index of the next element        // to be picked from list        public int j;         public Node(int a, int b, int c)        {            this.ele = a;            this.i = b;            this.j = c;        }    }     // A class for Min Heap    public class MinHeap {        // array of elements in heap        public Node[] harr;         // size of min heap        public int size;         // Constructor: creates a min heap        // of given size        public MinHeap(Node[] arr, int size)        {            this.harr = arr;            this.size = size;            int i = (size - 1) / 2;            while (i >= 0) {                MinHeapify(i);                i--;            }        }         // to get index of left child        // of node at index i        int left(int i)        {            return 2 * i + 1;        }         // to get index of right child        // of node at index i        int right(int i)        {            return 2 * i + 2;        }         // to heapify a subtree with        // root at given index        void MinHeapify(int i)        {            int l = left(i);            int r = right(i);            int small = i;            if (l < size && harr[l].ele < harr[i].ele)                small = l;            if (r < size && harr[r].ele < harr[small].ele)                small = r;            if (small != i) {                swap(small, i);                MinHeapify(small);            }        }         void swap(int i, int j)        {            Node temp = harr[i];            harr[i] = harr[j];            harr[j] = temp;        }         // to get the root        public Node getMin()        {            return harr[0];        }         // to replace root with new node x        // and heapify() new root        public void replaceMin(Node x)        {            harr[0] = x;            MinHeapify(0);        }    }     // This function takes an k sorted lists    // in the form of 2D array as an argument.    // It finds out smallest range that includes    // elements from each of the k lists.    static void findSmallestRange(int[, ] arr, int k)    {        int range = int.MaxValue;        int min = int.MaxValue;        int max = int.MinValue;        int start = -1, end = -1;         int n = arr.GetLength(0);         // Create a min heap with k heap nodes.        // Every heap node has first element of an list        Node[] arr1 = new Node[k];        for (int i = 0; i < k; i++) {            Node node = new Node(arr[i, 0], i, 1);            arr1[i] = node;             // store max element            max = Math.Max(max, node.ele);        }         // Create the heap        MinHeap mh = new MinHeap(arr1, k);         // Now one by one get the minimum element        // from min heap and replace it with        // next element of its list        while (true) {            // Get the minimum element and            // store it in output            Node root = mh.getMin();             // update min            min = root.ele;             // update range            if (range > max - min + 1) {                range = max - min + 1;                start = min;                end = max;            }             // Find the next element that will            // replace current root of heap.            // The next element belongs to same            // list as the current root.            if (root.j < n) {                root.ele = arr[root.i, root.j];                root.j++;                 // update max element                if (root.ele > max)                    max = root.ele;            }            else                break; // break if we have reached            // end of any list             // Replace root with next element of list            mh.replaceMin(root);        }        Console.Write("The smallest range is [" + start + " " + end + "]");    }     // Driver Code    public static void Main(String[] args)    {        int[, ] arr = { { 4, 7, 9, 12, 15 },                        { 0, 8, 10, 14, 20 },                        { 6, 12, 16, 30, 50 } };         int k = arr.GetLength(0);         findSmallestRange(arr, k);    }} // This code is contributed by Rajput-Ji
<script> // Javascript program to find out smallest// range that includes elements from// each of the given sorted lists.class Node{    constructor(a, b, c)    {        this.ele = a;        this.i = b;        this.j = c;    }} // A class for Min Heapclass MinHeap{         // Array of elements in heap    harr;         // Size of min heap    size;         // Constructor: creates a min heap    // of given size    constructor(arr,size)    {        this.harr = arr;        this.size = size;        let i = Math.floor((size - 1) / 2);                 while (i >= 0)        {            this.MinHeapify(i);            i--;        }    }         // To get index of left child    // of node at index i    left(i)    {        return 2 * i + 1;    }         // To get index of right child    // of node at index i    right(i)    {        return 2 * i + 2;    }         // To heapify a subtree with    // root at given index    MinHeapify(i)    {        let l = this.left(i);        let r = this.right(i);        let small = i;                 if (l < this.size &&                this.harr[l].ele <                this.harr[i].ele)            small = l;        if (r < this.size &&                this.harr[r].ele <                this.harr[small].ele)            small = r;        if (small != i)        {            this.swap(small, i);            this.MinHeapify(small);        }    }          swap(i, j)    {                 let temp = this.harr[i];        this.harr[i] = this.harr[j];        this.harr[j] = temp;    }         // To get the root    getMin()    {        return this.harr[0];    }         // To replace root with new node x    // and heapify() new root    replaceMin(x)    {        this.harr[0] = x;        this.MinHeapify(0);    } }  // This function takes an k sorted lists// in the form of 2D array as an argument.// It finds out smallest range that includes// elements from each of the k lists.function findSmallestRange(arr, k){    let range = Number.MAX_VALUE;    let min = Number.MAX_VALUE;    let max = Number.MIN_VALUE;    let start = -1, end = -1;    let n = arr[0].length;     // Create a min heap with k heap nodes.    // Every heap node has first element of an list    let arr1 = new Array(k);    for(let i = 0; i < k; i++)    {        let node = new Node(arr[i][0], i, 1);        arr1[i] = node;         // Store max element        max = Math.max(max, node.ele);    }     // Create the heap    let mh = new MinHeap(arr1, k);     // Now one by one get the minimum element    // from min heap and replace it with    // next element of its list    while (true)    {                 // Get the minimum element and        // store it in output        let root = mh.getMin();         // Update min        min = root.ele;         // Update range        if (range > max - min + 1)        {            range = max - min + 1;            start = min;            end = max;        }         // Find the next element that will        // replace current root of heap.        // The next element belongs to same        // list as the current root.        if (root.j < n)        {            root.ele = arr[root.i][root.j];            root.j++;             // Update max element            if (root.ele > max)                max = root.ele;        }                 // Break if we have reached        // end of any list        else            break;         // Replace root with next element of list        mh.replaceMin(root);    }    document.write("The smallest range is [" +                   start + " " + end + "]");} // Driver Codelet arr = [ [ 4, 7, 9, 12, 15 ],            [ 0, 8, 10, 14, 20 ],            [ 6, 12, 16, 30, 50 ] ];let k = arr.length; findSmallestRange(arr, k); // This code is contributed by rag2127 </script>
The smallest range is [6 8]
Complexity Analysis: Time complexity : O(n * k *log k). To find the maximum and minimum in a Min Heap of length k the time required is O(log k), and to traverse all the k arrays of length n (in the worst case), the time complexity is O(n*k), then the total time complexity is O(n * k *log k).Space complexity: O(k). The priority queue will store k elements so the space complexity of O(k)
Time complexity : O(n * k *log k). To find the maximum and minimum in a Min Heap of length k the time required is O(log k), and to traverse all the k arrays of length n (in the worst case), the time complexity is O(n*k), then the total time complexity is O(n * k *log k).
Space complexity: O(k). The priority queue will store k elements so the space complexity of O(k)
This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Rajput-Ji
mohit kumar 29
29AjayKumar
nobody_cares
andrew1234
unknown2108
arorakashish0911
rag2127
surindertarika1234
rkbhola5
debayanbiswas31
hardikkoriintern
Arrays
Hash
Arrays
Hash
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Search, insert and delete in an unsorted array
Window Sliding Technique
Chocolate Distribution Problem
Longest Consecutive Subsequence
What is Hashing | A Complete Tutorial
Hashing | Set 1 (Introduction)
Internal Working of HashMap in Java
Longest Consecutive Subsequence
Count pairs with given sum