# Kth smallest element from an array of intervals

Given an array of intervals arr[] of size N, the task is to find the Kth smallest element among all the elements within the intervals of the given array.

Examples:

Input : arr[] = {{5, 11}, {10, 15}, {12, 20}}, K =12
Output: 13
Explanation: Elements in the given array of intervals are: {5, 6, 7, 8, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 17, 18, 19, 20}.
Therefore, the Kth(=12th) smallest element is 13.

Input: arr[] = {{5, 11}, {10, 15}, {12, 20}}, K = 7
Output:10

Naive Approach: The simplest approach is to generate a new array consisting of all the elements from the array of intervals. Sort the new array. Finally, return the Kth smallest element of the array.

Time Complexity: O(X*Log(X)), where X is the total number of elements in the intervals.
Auxiliary Space: O(X*log(X))

Efficient approach: To optimize the above approach, the idea is to use MinHeap. Follow the steps below to solve the problem.

1. Create a MinHeap, say pq to store all the intervals of the given array so that it returns the minimum element among all the elements of remaining intervals in O(1).
2. Pop the minimum interval from the MinHeap and check if the minimum element of the popped interval is less than the maximum element of the popped interval. If found to be true, then insert a new interval {minimum element of popped interval + 1, maximum element of the popped interval}.
3. Repeat the above step K – 1 times.
4. Finally, return the minimum element of the popped interval.

Below is the implementation of the above approach:

## C++14

 `// C++ Program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to get the Kth smallest` `// element from an array of intervals` `int` `KthSmallestNum(pair<``int``, ``int``> arr[],` `                   ``int` `n, ``int` `k)` `{`   `    ``// Store all the intervals so that it` `    ``// returns the minimum element in O(1)` `    ``priority_queue,` `                   ``vector >,` `                   ``greater > >` `        ``pq;`   `    ``// Insert all Intervals into the MinHeap` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``pq.push({ arr[i].first,` `                  ``arr[i].second });` `    ``}`   `    ``// Stores the count of` `    ``// popped elements` `    ``int` `cnt = 1;`   `    ``// Iterate over MinHeap` `    ``while` `(cnt < k) {`   `        ``// Stores minimum element` `        ``// from all remaining intervals` `        ``pair<``int``, ``int``> interval` `            ``= pq.top();`   `        ``// Remove minimum element` `        ``pq.pop();`   `        ``// Check if the minimum of the current` `        ``// interval is less than the maximum` `        ``// of the current interval` `        ``if` `(interval.first < interval.second) {`   `            ``// Insert new interval` `            ``pq.push(` `                ``{ interval.first + 1,` `                  ``interval.second });` `        ``}`   `        ``cnt++;` `    ``}` `    ``return` `pq.top().first;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Intervals given` `    ``pair<``int``, ``int``> arr[]` `        ``= { { 5, 11 },` `            ``{ 10, 15 },` `            ``{ 12, 20 } };`   `    ``// Size of the arr` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``int` `k = 12;`   `    ``cout << KthSmallestNum(arr, n, k);` `}`

## Java

 `// Java program to implement ` `// the above approach ` `import` `java.util.*;` `import` `java.io.*;`   `class` `GFG{` `    `  `// Function to get the Kth smallest` `// element from an array of intervals` `public` `static` `int` `KthSmallestNum(``int` `arr[][], ``int` `n,` `                                 ``int` `k)` `{` `    `  `    ``// Store all the intervals so that it` `    ``// returns the minimum element in O(1)` `    ``PriorityQueue<``int``[]> pq = ``new` `PriorityQueue<>(` `                              ``(a, b) -> a[``0``] - b[``0``]);`   `    ``// Insert all Intervals into the MinHeap` `    ``for``(``int` `i = ``0``; i < n; i++)` `    ``{` `        ``pq.add(``new` `int``[]{arr[i][``0``], ` `                         ``arr[i][``1``]});` `    ``}`   `    ``// Stores the count of` `    ``// popped elements` `    ``int` `cnt = ``1``;`   `    ``// Iterate over MinHeap` `    ``while` `(cnt < k) ` `    ``{` `        `  `        ``// Stores minimum element` `        ``// from all remaining intervals` `        ``int``[] interval = pq.poll();`   `        ``// Check if the minimum of the current` `        ``// interval is less than the maximum` `        ``// of the current interval` `        ``if` `(interval[``0``] < interval[``1``])` `        ``{` `            `  `            ``// Insert new interval` `            ``pq.add(``new` `int``[]{interval[``0``] + ``1``,` `                             ``interval[``1``]});` `        ``}` `        ``cnt++;` `    ``}` `    ``return` `pq.peek()[``0``];` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    `  `    ``// Intervals given` `    ``int` `arr[][] = { { ``5``, ``11` `},` `                    ``{ ``10``, ``15` `}, ` `                    ``{ ``12``, ``20` `} };`   `    ``// Size of the arr` `    ``int` `n = arr.length;`   `    ``int` `k = ``12``;`   `    ``System.out.println(KthSmallestNum(arr, n, k));` `}` `}`   `// This code is contributed by hemanth gadarla`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to get the Kth smallest` `# element from an array of intervals` `def` `KthSmallestNum(arr, n, k):` `    `  `    ``# Store all the intervals so that it` `    ``# returns the minimum element in O(1)` `    ``pq ``=` `[]`   `    ``# Insert all Intervals into the MinHeap` `    ``for` `i ``in` `range``(n):` `        ``pq.append([arr[i][``0``], arr[i][``1``]])`   `    ``# Stores the count of` `    ``# popped elements` `    ``cnt ``=` `1`   `    ``# Iterate over MinHeap` `    ``while` `(cnt < k):` `        `  `        ``# Stores minimum element` `        ``# from all remaining intervals` `        ``pq.sort(reverse ``=` `True``)` `        ``interval ``=` `pq[``0``]`   `        ``# Remove minimum element` `        ``pq.remove(pq[``0``])`   `        ``# Check if the minimum of the current` `        ``# interval is less than the maximum` `        ``# of the current interval` `        ``if` `(interval[``0``] < interval[``1``]):` `            `  `            ``# Insert new interval` `            ``pq.append([interval[``0``] ``+` `1``, ` `                       ``interval[``1``]])`   `        ``cnt ``+``=` `1` `        `  `    ``pq.sort(reverse ``=` `True``)` `    ``return` `pq[``0``][``0``] ``+` `1`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Intervals given` `    ``arr ``=` `[ [ ``5``, ``11` `],` `            ``[ ``10``, ``15` `],` `            ``[ ``12``, ``20` `] ]`   `    ``# Size of the arr` `    ``n ``=` `len``(arr)` `    `  `    ``k ``=` `12` `    `  `    ``print``(KthSmallestNum(arr, n, k))`   `# This code is contributed by SURENDRA_GANGWAR`

## C#

 `// C# Program to implement` `// the above approach` `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;` `class` `GFG {` `    `  `    ``// Function to get the Kth smallest` `    ``// element from an array of intervals` `    ``static` `int` `KthSmallestNum(``int``[,] arr, ``int` `n, ``int` `k)` `    ``{` `        ``// Store all the intervals so that it` `        ``// returns the minimum element in O(1)` `        ``ArrayList pq = ``new` `ArrayList();` `     `  `        ``// Insert all Intervals into the MinHeap` `        ``for``(``int` `i = 0; i < n; i++)` `        ``{` `            ``pq.Add(``new` `Tuple<``int``,``int``>(arr[i,0], arr[i,1]));` `        ``}` `     `  `        ``// Stores the count of` `        ``// popped elements` `        ``int` `cnt = 1;` `     `  `        ``// Iterate over MinHeap` `        ``while` `(cnt < k)` `        ``{` `            ``// Stores minimum element` `            ``// from all remaining intervals` `            ``pq.Sort();` `            ``pq.Reverse();` `            ``Tuple<``int``,``int``> interval = (Tuple<``int``,``int``>)pq[0];` `     `  `            ``// Remove minimum element` `            ``pq.RemoveAt(0);` `     `  `            ``// Check if the minimum of the current` `            ``// interval is less than the maximum` `            ``// of the current interval` `            ``if` `(interval.Item1 < interval.Item2)` `            ``{` `                ``// Insert new interval` `                ``pq.Add(``new` `Tuple<``int``,``int``>(interval.Item1 + 1, interval.Item2));` `            ``}` `            ``cnt += 1;` `        ``} ` `        ``pq.Sort();` `        ``pq.Reverse();` `        ``return` `((Tuple<``int``,``int``>)pq[0]).Item1 + 1;` `    ``}` `    `  `  ``// Driver code` `  ``static` `void` `Main()` `  ``{` `    `  `    ``// Intervals given` `    ``int``[,] arr = { { 5, 11 },` `            ``{ 10, 15 },` `            ``{ 12, 20 } };` ` `  `    ``// Size of the arr` `    ``int` `n = arr.GetLength(0);` `    ``int` `k = 12;` `    ``Console.WriteLine(KthSmallestNum(arr, n, k));` `  ``}` `}`   `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`13`

Time Complexity: O(K*logK)
Auxiliary Space: O(N)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!