K’th Least Element in a Min-Heap
Last Updated :
30 Nov, 2023
Given a min-heap of size n, find the kth least element in the min-heap.
Examples:
Input : {10, 50, 40, 75, 60, 65, 45} k = 4
Output : 50
Input : {10, 50, 40, 75, 60, 65, 45} k = 2
Output : 40
Naive approach: We can extract the minimum element from the min-heap k times and the last element extracted will be the kth least element. Each deletion operation takes O(log n) time, so the total time complexity of this approach comes out to be O(k * log n).
Implementation:
C++
// C++ program to find k-th smallest
// element in Min Heap.
#include <bits/stdc++.h>
using namespace std;
// Structure for the heap
struct Heap {
vector<int> v;
int n; // Size of the heap
Heap(int i = 0)
: n(i)
{
v = vector<int>(n);
}
};
// Generic function to
// swap two integers
void swap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
// Returns the index of
// the parent node
inline int parent(int i)
{
return (i - 1) / 2;
}
// Returns the index of
// the left child node
inline int left(int i)
{
return 2 * i + 1;
}
// Returns the index of
// the right child node
inline int right(int i)
{
return 2 * i + 2;
}
// Maintains the heap property
void heapify(Heap& h, int i)
{
int l = left(i), r = right(i), m = i;
if (l < h.n && h.v[i] > h.v[l])
m = l;
if (r < h.n && h.v[m] > h.v[r])
m = r;
if (m != i) {
swap(h.v[m], h.v[i]);
heapify(h, m);
}
}
// Extracts the minimum element
int extractMin(Heap& h)
{
if (!h.n)
return -1;
int m = h.v[0];
h.v[0] = h.v[h.n-- - 1];
heapify(h, 0);
return m;
}
int findKthSmalles(Heap &h, int k)
{
for (int i = 1; i < k; ++i)
extractMin(h);
return extractMin(h);
}
int main()
{
Heap h(7);
h.v = vector<int>{ 10, 50, 40, 75, 60, 65, 45 };
int k = 2;
cout << findKthSmalles(h, k);
return 0;
}
import java.util.*;
// Class for the heap
class Heap {
List<Integer> v;
int n; // Size of the heap
Heap(int i) {
n = i;
v = new ArrayList<Integer>(Collections.nCopies(n, 0));
}
}
// Main class
public class Main {
// Generic function to swap two integers
public static void swap(int[] a, int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
// Returns the index of the parent node
public static int parent(int i) {
return (i - 1) / 2;
}
// Returns the index of the left child node
public static int left(int i) {
return 2 * i + 1;
}
// Returns the index of the right child node
public static int right(int i) {
return 2 * i + 2;
}
// Maintains the heap property
public static void heapify(Heap h, int i) {
int l = left(i), r = right(i), m = i;
if (l < h.n && h.v.get(i) > h.v.get(l))
m = l;
if (r < h.n && h.v.get(m) > h.v.get(r))
m = r;
if (m != i) {
Collections.swap(h.v, m, i);
heapify(h, m);
}
}
// Extracts the minimum element
public static int extractMin(Heap h) {
if (h.n == 0)
return -1;
int m = h.v.get(0);
h.v.set(0, h.v.get(h.n - 1));
h.n--;
heapify(h, 0);
return m;
}
public static int findKthSmallest(Heap h, int k) {
for (int i = 1; i < k; ++i)
extractMin(h);
return extractMin(h);
}
public static void main(String[] args) {
Heap h = new Heap(7);
h.v = Arrays.asList(10, 50, 40, 75, 60, 65, 45);
int k = 2;
System.out.println(findKthSmallest(h, k));
}
}
import heapq
# Structure for the heap
class Heap:
def __init__(self, i=0):
self.v = [0] * i
self.n = i
# Returns the index of the parent node
def parent(i):
return (i - 1) // 2
# Returns the index of the left child node
def left(i):
return 2 * i + 1
# Returns the index of the right child node
def right(i):
return 2 * i + 2
# Maintains the heap property
def heapify(h, i):
l, r, m = left(i), right(i), i
if l < h.n and h.v[i] > h.v[l]:
m = l
if r < h.n and h.v[m] > h.v[r]:
m = r
if m != i:
h.v[i], h.v[m] = h.v[m], h.v[i]
heapify(h, m)
# Extracts the minimum element
def extractMin(h):
if not h.n:
return -1
m = h.v[0]
h.v[0] = h.v[h.n - 1]
h.n -= 1
heapify(h, 0)
return m
def findKthSmallest(h, k):
for i in range(1, k):
extractMin(h)
return extractMin(h)
h = Heap(7)
h.v = [10, 50, 40, 75, 60, 65, 45]
k = 2
print(findKthSmallest(h, k))
using System;
using System.Collections.Generic;
using System.Linq;
public class Heap {
public List<int> v;
public int n { get; private set; } // Size of the heap
public Heap(int i) {
n = i;
v = Enumerable.Repeat(0, n).ToList();
}
// Maintains the heap property
private void heapify(int i) {
int l = left(i), r = right(i), m = i;
if (l < n && v[i] > v[l])
m = l;
if (r < n && v[m] > v[r])
m = r;
if (m != i) {
swap(v, m, i);
heapify(m);
}
}
// Extracts the minimum element
public int extractMin() {
if (n == 0)
return -1;
int m = v[0];
v[0] = v[n - 1];
n--;
heapify(0);
return m;
}
public int findKthSmallest(int k) {
for (int i = 1; i < k; ++i)
extractMin();
return extractMin();
}
// Returns the index of the parent node
private static int parent(int i) {
return (i - 1) / 2;
}
// Returns the index of the left child node
private static int left(int i) {
return 2 * i + 1;
}
// Returns the index of the right child node
private static int right(int i) {
return 2 * i + 2;
}
// Generic function to swap two integers
private static void swap(List<int> a, int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
public class MainClass {
public static void Main(string[] args) {
Heap h = new Heap(7);
h.v = new List<int> { 10, 50, 40, 75, 60, 65, 45 };
int k = 2;
Console.WriteLine(h.findKthSmallest(k));
}
}
// Structure for the heap
class Heap {
constructor(i = 0) {
this.v = new Array(i);
this.n = i; // Size of the heap
}
}
// Returns the index of
// the parent node
function parent(i) {
return Math.floor((i - 1) / 2);
}
// Returns the index of
// the left child node
function left(i) {
return 2 * i + 1;
}
// Returns the index of
// the right child node
function right(i) {
return 2 * i + 2;
}
// Maintains the heap property
function heapify(h, i) {
let l = left(i),
r = right(i),
m = i;
if (l < h.n && h.v[i] > h.v[l]) m = l;
if (r < h.n && h.v[m] > h.v[r]) m = r;
if (m != i) {
let temp = h.v[m];
h.v[m] = h.v[i];
h.v[i] = temp;
heapify(h, m);
}
}
// Extracts the minimum element
function extractMin(h) {
if (!h.n) return -1;
let m = h.v[0];
h.v[0] = h.v[h.n-- - 1];
heapify(h, 0);
return m;
}
function findKthSmallest(h, k) {
for (let i = 1; i < k; ++i) extractMin(h);
return extractMin(h);
}
const h = new Heap(7);
h.v = [10, 50, 40, 75, 60, 65, 45];
const k = 2;
console.log(findKthSmallest(h, k));
Time Complexity: O(k * log n)
Efficient approach:
We can note an interesting observation about min-heap. An element x at ith level has i - 1 ancestor. By the property of min-heaps, these i - 1 ancestors are guaranteed to be less than x. This implies that x cannot be among the least i - 1 element of the heap. Using this property, we can conclude that the kth least element can have a level of at most k. We can reduce the size of the min-heap such that it has only k levels. We can then obtain the kth least element by our previous strategy of extracting the minimum element k times.
Note that the size of the heap is reduced to a maximum of 2k - 1, therefore each heapify operation will take O(log 2k) = O(k) time. The total time complexity will be O(k2). If n >> k, then this approach performs better than the previous one.
Implementation:
C++
// C++ program to find k-th smallest
// element in Min Heap using k levels
#include <bits/stdc++.h>
using namespace std;
// Structure for the heap
struct Heap {
vector<int> v;
int n; // Size of the heap
Heap(int i = 0)
: n(i)
{
v = vector<int>(n);
}
};
// Generic function to
// swap two integers
void swap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
// Returns the index of
// the parent node
inline int parent(int i) { return (i - 1) / 2; }
// Returns the index of
// the left child node
inline int left(int i) { return 2 * i + 1; }
// Returns the index of
// the right child node
inline int right(int i) { return 2 * i + 2; }
// Maintains the heap property
void heapify(Heap& h, int i)
{
int l = left(i), r = right(i), m = i;
if (l < h.n && h.v[i] > h.v[l])
m = l;
if (r < h.n && h.v[m] > h.v[r])
m = r;
if (m != i) {
swap(h.v[m], h.v[i]);
heapify(h, m);
}
}
// Extracts the minimum element
int extractMin(Heap& h)
{
if (!h.n)
return -1;
int m = h.v[0];
h.v[0] = h.v[h.n-- - 1];
heapify(h, 0);
return m;
}
int findKthSmalles(Heap& h, int k)
{
h.n = min(h.n, int(pow(2, k) - 1));
for (int i = 1; i < k; ++i)
extractMin(h);
return extractMin(h);
}
int main()
{
Heap h(7);
h.v = vector<int>{ 10, 50, 40, 75, 60, 65, 45 };
int k = 2;
cout << findKthSmalles(h, k);
return 0;
}
// Java program to find k-th smallest
// element in Min Heap using k levels
import java.util.*;
// Structure for the heap
class Heap {
Vector<Integer> v;
int n; // Size of the heap
Heap(int i)
{
n = i;
v = new Vector<Integer>(n);
}
}
public class Main {
// Generic function to
// swap two integers
static void swap(Vector<Integer> v, int a, int b)
{
int temp = v.get(a);
v.set(a, v.get(b));
v.set(b, temp);
}
// Returns the index of
// the parent node
static int parent(int i) { return (i - 1) / 2; }
// Returns the index of
// the left child node
static int left(int i) { return 2 * i + 1; }
// Returns the index of
// the right child node
static int right(int i) { return 2 * i + 2; }
// Maintains the heap property
static void heapify(Heap h, int i)
{
int l = left(i), r = right(i), m = i;
if (l < h.n && h.v.get(i) > h.v.get(l))
m = l;
if (r < h.n && h.v.get(m) > h.v.get(r))
m = r;
if (m != i) {
swap(h.v, m, i);
heapify(h, m);
}
}
// Extracts the minimum element
static int extractMin(Heap h)
{
if (h.n == 0)
return -1;
int m = h.v.get(0);
h.v.set(0, h.v.get(h.n-- - 1));
heapify(h, 0);
return m;
}
static int findKthSmalles(Heap h, int k)
{
h.n = Math.min(h.n, (int)Math.pow(2, k) - 1);
for (int i = 1; i < k; ++i)
extractMin(h);
return extractMin(h);
}
public static void main(String[] args)
{
Heap h = new Heap(7);
h.v = new Vector<Integer>(
Arrays.asList(10, 50, 40, 75, 60, 65, 45));
int k = 2;
System.out.println(findKthSmalles(h, k));
}
}
# Python program to find k-th smallest
# element in Min Heap using k levels
import math
# Structure for the heap
class Heap:
def __init__(self, i=0):
self.v = [0] * i
self.n = i # Size of the heap
# Generic function to
# swap two integers
def swap(a, b):
temp = a
a = b
b = temp
return a, b
# Returns the index of
# the parent node
def parent(i):
return (i - 1) // 2
# Returns the index of
# the left child node
def left(i):
return 2 * i + 1
# Returns the index of
# the right child node
def right(i):
return 2 * i + 2
# Maintains the heap property
def heapify(h, i):
l, r, m = left(i), right(i), i
if l < h.n and h.v[i] > h.v[l]:
m = l
if r < h.n and h.v[m] > h.v[r]:
m = r
if m != i:
h.v[m], h.v[i] = swap(h.v[m], h.v[i])
heapify(h, m)
# Extracts the minimum element
def extractMin(h):
if not h.n:
return -1
m = h.v[0]
h.v[0] = h.v[h.n - 1]
h.n -= 1
heapify(h, 0)
return m
def findKthSmallest(h, k):
h.n = min(h.n, int(math.pow(2, k) - 1))
for i in range(1, k):
extractMin(h)
return extractMin(h)
if __name__ == '__main__':
h = Heap(7)
h.v = [10, 50, 40, 75, 60, 65, 45]
k = 2
print(findKthSmallest(h, k))
using System;
using System.Collections.Generic;
using System.Linq;
public class Heap {
public List<int> v;
public int n; // Size of the heap
public Heap(int i)
{
n = i;
v = new List<int>(n);
}
}
public class MainClass {
// Generic function to
// swap two integers
static void swap(List<int> v, int a, int b)
{
int temp = v[a];
v[a] = v[b];
v[b] = temp;
}
// Returns the index of
// the parent node
static int parent(int i) { return (i - 1) / 2; }
// Returns the index of
// the left child node
static int left(int i) { return 2 * i + 1; }
// Returns the index of
// the right child node
static int right(int i) { return 2 * i + 2; }
// Maintains the heap property
static void heapify(Heap h, int i)
{
int l = left(i), r = right(i), m = i;
if (l < h.n && h.v[i] > h.v[l])
m = l;
if (r < h.n && h.v[m] > h.v[r])
m = r;
if (m != i) {
swap(h.v, m, i);
heapify(h, m);
}
}
// Extracts the minimum element
static int extractMin(Heap h)
{
if (h.n == 0)
return -1;
int m = h.v[0];
h.v[0] = h.v[h.n-- - 1];
heapify(h, 0);
return m;
}
static int findKthSmalles(Heap h, int k)
{
h.n = Math.Min(h.n, (int)Math.Pow(2, k) - 1);
for (int i = 1; i < k; ++i)
extractMin(h);
return extractMin(h);
}
public static void Main(string[] args)
{
Heap h = new Heap(7);
h.v = new List<int>(
new int[] { 10, 50, 40, 75, 60, 65, 45 });
int k = 2;
Console.WriteLine(findKthSmalles(h, k));
}
}
// JavaScript program to find k-th smallest
// element in Min Heap using k levels
// Structure for the heap
class Heap {
constructor(i = 0) {
this.v = new Array(i).fill(0);
this.n = i; // Size of the heap
}
}
// Generic function to
// swap two integers
function swap(a, b) {
const temp = a;
a = b;
b = temp;
return [a, b];
}
// Returns the index of
// the parent node
function parent(i) {
return Math.floor((i - 1) / 2);
}
// Returns the index of
// the left child node
function left(i) {
return 2 * i + 1;
}
// Returns the index of
// the right child node
function right(i) {
return 2 * i + 2;
}
// Maintains the heap property
function heapify(h, i) {
let l = left(i);
let r = right(i);
let m = i;
if (l < h.n && h.v[i] > h.v[l]) {
m = l;
}
if (r < h.n && h.v[m] > h.v[r]) {
m = r;
}
if (m != i) {
[h.v[m], h.v[i]] = swap(h.v[m], h.v[i]);
heapify(h, m);
}
}
// Extracts the minimum element
function extractMin(h) {
if (!h.n) {
return -1;
}
let m = h.v[0];
h.v[0] = h.v[h.n - 1];
h.n--;
heapify(h, 0);
return m;
}
function findKthSmallest(h, k) {
h.n = Math.min(h.n, Math.pow(2, k) - 1);
for (let i = 1; i < k; i++) {
extractMin(h);
}
return extractMin(h);
}
const h = new Heap(7);
h.v = [10, 50, 40, 75, 60, 65, 45];
const k = 2;
console.log(findKthSmallest(h, k));
Time Complexity: O(k2) More efficient approach:
We can further improve the time complexity of this problem by the following algorithm:
- Create a priority queue P (or Min Heap) and insert the root node of the min-heap into P. The comparator function of the priority queue should be such that the least element is popped.
- Repeat these steps k - 1 times:
- Pop the least element from P.
- Insert left and right child elements of the popped element. (if they exist).
- The least element in P is the kth least element of the min-heap.
The initial size of the priority queue is one, and it increases by at most one at each of the k - 1 steps. Therefore, there are maximum k elements in the priority queue and the time complexity of the pop and insert operations is O(log k). Thus the total time complexity is O(k * log k).
Implementation:
C++
// C++ program to find k-th smallest
// element in Min Heap using another
// Min Heap (Or Priority Queue)
#include <bits/stdc++.h>
using namespace std;
// Structure for the heap
struct Heap {
vector<int> v;
int n; // Size of the heap
Heap(int i = 0)
: n(i)
{
v = vector<int>(n);
}
};
// Returns the index of
// the left child node
inline int left(int i)
{
return 2 * i + 1;
}
// Returns the index of
// the right child node
inline int right(int i)
{
return 2 * i + 2;
}
int findKthSmalles(Heap &h, int k)
{
// Create a Priority Queue
priority_queue<pair<int, int>,
vector<pair<int, int> >,
greater<pair<int, int> > >
p;
// Insert root into the priority queue
p.push(make_pair(h.v[0], 0));
for (int i = 0; i < k - 1; ++i) {
int j = p.top().second;
p.pop();
int l = left(j), r = right(j);
if (l < h.n)
p.push(make_pair(h.v[l], l));
if (r < h.n)
p.push(make_pair(h.v[r], r));
}
return p.top().first;
}
int main()
{
Heap h(7);
h.v = vector<int>{ 10, 50, 40, 75, 60, 65, 45 };
int k = 4;
cout << findKthSmalles(h, k);
return 0;
}
import java.util.PriorityQueue;
// Structure for the heap
class Heap {
int[] v;
int n; // Size of the heap
Heap(int i) {
n = i;
v = new int[n];
}
}
public class Main {
// Returns the index of the left child node
static int left(int i) {
return 2 * i + 1;
}
// Returns the index of the right child node
static int right(int i) {
return 2 * i + 2;
}
static int findKthSmallest(Heap h, int k) {
// Create a Priority Queue
PriorityQueue<int[]> p = new PriorityQueue<>((a, b) -> Integer.compare(a[0], b[0]));
// Insert root into the priority queue
p.add(new int[]{h.v[0], 0});
for (int i = 0; i < k - 1; i++) {
int[] top = p.poll();
int j = top[1];
int l = left(j), r = right(j);
if (l < h.n) {
p.add(new int[]{h.v[l], l});
}
if (r < h.n) {
p.add(new int[]{h.v[r], r});
}
}
return p.peek()[0];
}
public static void main(String[] args) {
Heap h = new Heap(7);
h.v = new int[]{10, 50, 40, 75, 60, 65, 45};
int k = 4;
System.out.println(findKthSmallest(h, k));
}
}
# Python program to find k-th smallest
# element in Min Heap using another
# Min Heap (Or Priority Queue)
import heapq
# Structure for the heap
class Heap:
def __init__(self, n):
self.v = [0] * n
self.n = n
# Returns the index of
# the left child node
def left(i):
return 2 * i + 1
# Returns the index of
# the right child node
def right(i):
return 2 * i + 2
def findKthSmalles(h, k):
# Create a Priority Queue
p = []
# Insert root into the priority queue
heapq.heappush(p, (h.v[0], 0))
for i in range(k - 1):
j = heapq.heappop(p)[1]
l, r = left(j), right(j)
if l < h.n:
heapq.heappush(p, (h.v[l], l))
if r < h.n:
heapq.heappush(p, (h.v[r], r))
return p[0][0]
# Main function
def main():
h = Heap(7)
h.v = [10, 50, 40, 75, 60, 65, 45]
k = 4
print(findKthSmalles(h, k))
if __name__ == '__main__':
main()
using System;
using System.Collections.Generic;
using System.Linq;
public class Heap
{
private int[] v; // Array to store the heap elements
private int n; // Size of the heap
public Heap(int size)
{
v = new int[size]; // Initialize the array for the heap
n = size; // Set the size of the heap
}
// Returns the index of the left child node
private int Left(int i)
{
return 2 * i + 1;
}
// Returns the index of the right child node
private int Right(int i)
{
return 2 * i + 2;
}
// Function to find the k-th smallest element in the heap
public int FindKthSmallest(int k)
{
// Create a Priority Queue using SortedDictionary
var p = new SortedDictionary<int, int>();
// Insert root into the priority queue
p.Add(v[0], 0);
// Iterate k-1 times to find the k-th smallest element
for (int i = 0; i < k - 1; i++)
{
var item = p.First(); // Get the smallest element from the priority queue
p.Remove(item.Key); // Remove the smallest element
int j = item.Value; // Get the index of the smallest element in the heap
int l = Left(j); // Calculate the index of the left child
int r = Right(j); // Calculate the index of the right child
// Add left child to the priority queue if within the heap size
if (l < n)
p.Add(v[l], l);
// Add right child to the priority queue if within the heap size
if (r < n)
p.Add(v[r], r);
}
return p.Keys.First(); // Return the smallest element (k-th smallest)
}
public static void Main(string[] args)
{
Heap h = new Heap(7); // Create a new heap with size 7
h.v = new int[] { 10, 50, 40, 75, 60, 65, 45 }; // Assign heap elements
int k = 4; // Define the value of k
Console.WriteLine(h.FindKthSmallest(k)); // Print the k-th smallest element
}
}
class Heap {
constructor(i) {
this.n = i; // Size of the heap
this.v = new Array(this.n);
}
}
// Returns the index of the left child node
function left(i) {
return 2 * i + 1;
}
// Returns the index of the right child node
function right(i) {
return 2 * i + 2;
}
function findKthSmallest(h, k) {
// Create a Priority Queue
const p = new MinHeap((a, b) => a[0] - b[0]);
// Insert root into the priority queue
p.add([h.v[0], 0]);
for (let i = 0; i < k - 1; i++) {
const top = p.poll();
const j = top[1];
const l = left(j);
const r = right(j);
if (l < h.n) {
p.add([h.v[l], l]);
}
if (r < h.n) {
p.add([h.v[r], r]);
}
}
return p.peek()[0];
}
class MinHeap {
constructor(comparator) {
this.heap = [];
this.comparator = comparator;
}
add(item) {
this.heap.push(item);
this.heapifyUp();
}
poll() {
if (this.isEmpty()) {
throw new Error('The heap is empty.');
}
if (this.heap.length === 1) {
return this.heap.pop();
}
const min = this.heap[0];
this.heap[0] = this.heap.pop();
this.heapifyDown();
return min;
}
peek() {
if (this.isEmpty()) {
throw new Error('The heap is empty.');
}
return this.heap[0];
}
isEmpty() {
return this.heap.length === 0;
}
size() {
return this.heap.length;
}
heapifyUp() {
let currentIndex = this.heap.length - 1;
while (this.hasParent(currentIndex) && this.compare(currentIndex, this.parentIndex(currentIndex)) < 0) {
this.swap(currentIndex, this.parentIndex(currentIndex));
currentIndex = this.parentIndex(currentIndex);
}
}
heapifyDown() {
let currentIndex = 0;
while (this.hasLeftChild(currentIndex)) {
let smallerChildIndex = this.leftChildIndex(currentIndex);
if (this.hasRightChild(currentIndex) && this.compare(this.leftChildIndex(currentIndex), this.rightChildIndex(currentIndex)) > 0) {
smallerChildIndex = this.rightChildIndex(currentIndex);
}
if (this.compare(currentIndex, smallerChildIndex) < 0) {
break;
} else {
this.swap(currentIndex, smallerChildIndex);
}
currentIndex = smallerChildIndex;
}
}
hasParent(index) {
return index > 0;
}
parentIndex(index) {
return Math.floor((index - 1) / 2);
}
hasLeftChild(index) {
return this.leftChildIndex(index) < this.heap.length;
}
leftChildIndex(index) {
return index * 2 + 1;
}
hasRightChild(index) {
return this.rightChildIndex(index) < this.heap.length;
}
rightChildIndex(index) {
return index * 2 + 2;
}
compare(index1, index2) {
return this.comparator(this.heap[index1], this.heap[index2]);
}
swap(index1, index2) {
const temp = this.heap[index1];
this.heap[index1] = this.heap[index2];
this.heap[index2] = temp;
}
}
// Main function
function main() {
const h = new Heap(7);
h.v = [10, 50, 40, 75, 60, 65, 45];
const k = 4;
console.log(findKthSmallest(h, k));
}
// Call the main function
main();
Time Complexity: O(k * log k)
Similar Reads
Minimum element in a max heap
Given a max heap, find the minimum element present in the heap. Examples: Input : 100 / \ 75 50 / \ / \ 55 10 2 40 Output : 2 Input : 20 / \ 4 18 Output : 4 Brute force approach: We can check all the nodes in the max heap to get the minimum element. Note that this approach works on any binary tree a
9 min read
K'th largest element in a stream
Given an input stream of n integers, represented as an array arr[], and an integer k. After each insertion of an element into the stream, you need to determine the kth largest element so far (considering all elements including duplicates). If k elements have not yet been inserted, return -1 for that
15+ min read
K-th Greatest Element in a Max-Heap
Given a max-heap of size n, find the kth greatest element in the max-heap. Examples: Input : maxHeap = {20, 15, 18, 8, 10, 5, 17} k = 4 Output : 15 Input : maxHeap = {100, 50, 80, 10, 25, 20, 75} k = 2 Output : 80 Naive approach: We can extract the maximum element from the max-heap k times and the l
15+ min read
Maximum element in min heap
Given a min heap, find the maximum element present in the heap. Examples: Input : 10 / \ 25 23 / \ / \ 45 30 50 40 Output : 50 Input : 20 / \ 40 28 Output : 40 Brute force approach: We can check all the nodes in the min-heap to get the maximum element. Note that this approach works on any binary tre
8 min read
Find elements having at least K times the minimum frequency
Given an array A, the task is to find elements with the occurrence at least K times the frequency of the least occurring element in the array. Examples: Input: A = {4, 4, 3, 6, 6, 6, 8, 9}, K = 2Output: {4, 6}Explanation: Frequency Table : {4:2, 3:1, 6:3, 8:1, 9:1}, least occurring elements in nums
6 min read
K’th Smallest Element in Unsorted Array
Given an array arr[] of N distinct elements and a number K, where K is smaller than the size of the array. Find the K'th smallest element in the given array. Examples:Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 3 Output: 7Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 4 Output: 10 Table of Content[Naive Ap
15 min read
Python heapq to find K'th smallest element in a 2D array
Given an n x n matrix and integer k. Find the k'th smallest element in the given 2D array. Examples: Input : mat = [[10, 25, 20, 40], [15, 45, 35, 30], [24, 29, 37, 48], [32, 33, 39, 50]] k = 7 Output : 7th smallest element is 30 We will use similar approach like K’th Smallest/Largest Element in Uns
3 min read
K'th smallest element in BST using O(1) Extra Space
Given a Binary Search Tree (BST) and a positive integer k, find the k’th smallest element in the Binary Search Tree. Example:Input: k = 3 Output: 10Explanation: The inorder traversal of given BST is [4, 8, 10, 12, 14, 20, 22] and its 3rd smallest element is 10.Approach: The idea is to perform in-ord
9 min read
Least frequent element in an array
Given an array, find the least frequent element in it. If there are multiple elements that appear least number of times, print any one of them. Examples : Input : arr[] = {1, 3, 2, 1, 2, 2, 3, 1}Output : 3Explanation: 3 appears minimum number of times in given array. Input : arr[] = {10, 20, 30}Outp
11 min read
Insertion and Deletion in Heaps
Deletion in Heap:Given a Binary Heap and an element present in the given Heap. The task is to delete an element from this Heap. The standard deletion operation on Heap is to delete the element present at the root node of the Heap. That is if it is a Max Heap, the standard deletion operation will del
15+ min read