# Find smallest range containing elements from k lists

Given k sorted lists of integers of size n each, find the smallest range that includes at least element from each of the k lists. If more than one smallest ranges are 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 first list, 8 from second
list and 6 from third list.

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

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Naive approach : The idea is to maintain pointers to every list using array ptr[k].Below are the steps :

1. Initially the index of every list is 0,therefore initialize every element of ptr[0..k] to 0;
2. Repeat the following steps until atleast 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.

## C++

 `// C++ program to finds out smallest range that includes ` `// elements from each of the given sorted lists. ` `#include ` ` `  `using` `namespace` `std; ` ` `  `#define N 5 ` ` `  `// array for storing the current index of list i ` `int` `ptr; ` ` `  `// 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 mainting 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 function ` `int` `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); ` `  `  `    ``findSmallestRange(arr,N,k); ` `  `  `    ``return` `0; ` `} ` `// This code is contributed by Aditya Krishna Namdeo `

## Java

 `// 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 mainting 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 `

## Python

 `# 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 i ` `ptr ``=` `[``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 mainting 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 code ` `arr``=` `[ ` `    ``[``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#

 `// 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``;  ` ` `  `    ``// 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 mainting 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 `

Output :

`The smallest range is [6 8]`

Time complexity : O(n2 k)

A Better efficient approach is to use min heap. Below are the steps –

1. Create a min heap of size k and insert first elements of all k lists into the heap.
2. Maintain two variables min and max to store minimum and maximum values present in the heap at any point. Note min will always contain value of the root of the heap.
3. Repeat following steps
• Get minimum element from heap (minimum is always at root) and compute the range.
• Replace heap root with next element of the list from which the min element is extracted. After replacing the root, heapify the tree. Update max if next element is greater. If the list doesn’t have any more elements, break the loop.

Below is the implementation of above approach –

## C++

 `// C++ program to finds out smallest range that includes ` `// elements from each of the given sorted lists. ` `#include ` `using` `namespace` `std; ` ` `  `#define N 5 ` ` `  `// A min heap node ` `struct` `MinHeapNode ` `{ ` `    ``int` `element; ``// The element to be stored ` `    ``int` `i; ``// index of the list from which the element is taken ` `    ``int` `j; ``// index of the next element to be picked from list ` `}; ` ` `  `// Prototype of a utility function to swap two min heap nodes ` `void` `swap(MinHeapNode *x, MinHeapNode *y); ` ` `  `// A class for Min Heap ` `class` `MinHeap ` `{ ` `    ``MinHeapNode *harr; ``// pointer to array of elements in heap ` `    ``int` `heap_size; ``// size of min heap ` `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; } ` ` `  `    ``// to replace root with new node x and heapify() new root ` `    ``void` `replaceMin(MinHeapNode x) { harr = x; MinHeapify(0); } ` `}; ` ` `  `// Constructor: Builds a heap from a given array a[] of given size ` `MinHeap::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 heapified ` `void` `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++) ` `    ``{ ` `        ``harr[i].element = arr[i]; ``// Store the first element ` `        ``harr[i].i = i; ``// index of list ` `        ``harr[i].j = 1; ``// Index of next element to be stored ` `                       ``// from list ` ` `  `        ``// store max element ` `        ``if` `(harr[i].element > max) ` `            ``max = harr[i].element; ` `    ``} ` ` `  `    ``MinHeap hp(harr, k); ``// Create the heap ` ` `  `    ``// 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 functions ` `int` `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); ` ` `  `    ``findSmallestRange(arr, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// 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  ` `    ``{ ` `        ``int` `ele; ``// The element to be stored ` `        ``int` `i;     ``// index of the list from which  ` `                 ``// the element is taken ` `        ``int` `j;     ``// index of the next element ` `                 ``// to be picked from list ` ` `  `        ``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; ` `            ``} ``else` `                ``break``;    ``// break if we have reached ` `                        ``// end of any list ` ` `  `            ``// 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#

 `// 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  ` `    ``{ ` `        ``public` `int` `ele;  ``// The element to be stored ` `        ``public` `int` `i;     ``// index of the list from which  ` `                         ``// the element is taken ` `        ``public` `int` `j;     ``// index of the next element ` `                         ``// to be picked from list ` ` `  `        ``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 ` `    ``{ ` `        ``public` `Node[] harr;  ``// array of elements in heap ` `        ``public` `int` `size;     ``// size of min heap ` ` `  `        ``// 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; ` `        ``} ` ` `  `        ``// to replace root with new node x ` `        ``// and heapify() new root ` `        ``public` `void` `replaceMin(Node x) ` `        ``{ ` `            ``harr = 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 `

Output :

`The smallest range is [6 8]`

Time Complexity:
The while loop inside findSmallestRange() function can run maximum n*k times. In every iteration of loop, we call heapify which takes O(Logk) time. Therefore, the time complexity is O(nk Logk).