Kth Largest Element Using Max Heap in DSA C++

Mental Model

We use a max heap to keep track of the largest elements so we can quickly find the kth largest by removing the largest elements one by one.

Analogy: Imagine a pile of books stacked by height. The tallest book is on top. To find the kth tallest book, you remove the tallest books one by one until you reach the kth.

Max Heap Array Representation:
[ 9, 7, 8, 5, 6, 3, 4 ]
Heap Tree:
       9
     /   \
    7     8
   / \   / \
  5   6 3   4
↑ (root is largest)

Dry Run Walkthrough

Input: array: [3, 2, 1, 5, 6, 4], k = 2

Goal: Find the 2nd largest element in the array using a max heap

Step 1: Build max heap from array

[6, 5, 4, 2, 3, 1]

Why: We rearrange the array so the largest element is at the root for easy access

Step 2: Remove the largest element (6) from heap

[5, 3, 4, 2, 1]

Why: The root now is the 2nd largest element, which is our answer

Result:

[5, 3, 4, 2, 1]
Answer: 5

Annotated Code

DSA C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int findKthLargest(vector<int>& nums, int k) {
    // Build max heap from nums
    make_heap(nums.begin(), nums.end());

    // Remove the largest element k-1 times
    for (int i = 0; i < k - 1; ++i) {
        pop_heap(nums.begin(), nums.end());
        nums.pop_back();
    }

    // The root of the heap is now the kth largest
    return nums.front();
}

int main() {
    vector<int> nums = {3, 2, 1, 5, 6, 4};
    int k = 2;
    int result = findKthLargest(nums, k);
    cout << "Kth largest element is: " << result << endl;
    return 0;
}

make_heap(nums.begin(), nums.end());

Build max heap from the input array to organize elements by largest at root

pop_heap(nums.begin(), nums.end());

Move the largest element (root) to the end of the vector

nums.pop_back();

Remove the largest element from the heap to reduce heap size

return nums.front();

Return the root of the heap which is the kth largest element

Output

Kth largest element is: 5

Complexity Analysis

Time: O(n + k log n) because building the heap takes O(n) and each pop operation takes O(log n) repeated k times

Space: O(1) because the heap is built in-place in the input array

vs Alternative: Sorting the array takes O(n log n), which is slower than heap approach when k is small

Edge Cases

k is 1 (find largest element)

Returns the maximum element directly after building the heap

DSA C++

for (int i = 0; i < k - 1; ++i) { ... } handles zero iterations when k=1

k equals array size (find smallest element)

Removes all larger elements until the smallest remains at root

DSA C++

for loop runs k-1 times to pop all larger elements

array with duplicate elements

Duplicates are handled normally as heap stores all elements

DSA C++

make_heap and pop_heap work correctly with duplicates

When to Use This Pattern

When asked to find the kth largest or smallest element efficiently, think of using a heap to avoid full sorting.

Common Mistakes

Mistake: Not building the heap before popping elements
Fix: Always call make_heap before pop_heap to ensure heap property

Mistake: Removing elements fewer or more times than k-1
Fix: Remove exactly k-1 largest elements so the root is kth largest

Summary

Finds the kth largest element by building a max heap and removing the largest elements k-1 times.

Use when you want to find kth largest without sorting the entire array.

The largest element is always at the root of a max heap, so popping k-1 times reveals the kth largest.

Practice

1. What is the main idea behind finding the kth largest element using a max heap?

easy

A. Use a hash map to count frequencies and find the kth largest

B. Build a max heap from the array and extract the maximum element k times

C. Sort the array and pick the kth element from the start

D. Build a min heap and extract the minimum element k times

Solution

1. Step 1: Understand max heap property

   A max heap always keeps the largest element at the root, so extracting the root gives the current largest element.

2. Step 2: Extract max k times

   By removing the root k times, the last extracted element is the kth largest.

3. Final Answer:

   Build max heap and extract max k times -> Option B

4. Quick Check:

   Max heap extraction = kth largest element [OK]

Hint: Extract max from max heap k times to get kth largest [OK]

Common Mistakes:

• Using min heap instead of max heap
• Sorting and picking wrong index
• Confusing kth largest with kth smallest

2. Which of the following is the correct C++ syntax to create a max heap from a vector nums in-place?

easy

A. std::priority_queue maxHeap(nums.begin(), nums.end());

B. std::make_heap(nums.begin(), nums.end(), std::greater<int>());

C. std::priority_queue<int> maxHeap(nums.begin(), nums.end());

D. std::make_heap(nums.begin(), nums.end());

Solution

1. Step 1: Understand std::make_heap default behavior

   By default, std::make_heap creates a max heap using operator<.

2. Step 2: Check syntax correctness

   std::make_heap(nums.begin(), nums.end()); correctly calls std::make_heap on the vector range without extra comparators, making a max heap in-place.

3. Final Answer:

   std::make_heap(nums.begin(), nums.end()); -> Option D

4. Quick Check:

   Default make_heap = max heap [OK]

Hint: Use std::make_heap without comparator for max heap [OK]

Common Mistakes:

• Using std::greater<int>() creates min heap
• Incorrect priority_queue constructor usage
• Confusing comparator direction

3. What is the output of the following C++ code snippet?

std::vector<int> nums = {3, 2, 1, 5, 6, 4};
std::make_heap(nums.begin(), nums.end());
for (int i = 0; i < 2; ++i) {
  std::pop_heap(nums.begin(), nums.end() - i);
}
int kthLargest = nums[0];
std::cout << kthLargest << std::endl;

medium

A. 4

B. 6

C. 5

D. 3

Solution

1. Step 1: Build max heap from nums

   Heap after make_heap is [6, 5, 4, 2, 3, 1] (largest at front).

2. Step 2: Perform two pop_heap operations

   First pop_heap moves 6 to end, second pop_heap moves 5 next to end. Now, nums[0] is 5.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   After 2 pops, root = 5 [OK]

Hint: After popping max twice, root is 3rd largest [OK]

Common Mistakes:

• Assuming root stays 6 after pops
• Confusing pop_heap with pop_back
• Not adjusting heap size correctly

4. Identify the error in the following code to find the 3rd largest element using a max heap:

std::vector<int> nums = {7, 10, 4, 3, 20, 15};
std::priority_queue<int> maxHeap(nums.begin(), nums.end());
int kthLargest;
for (int i = 0; i < 3; ++i) {
  kthLargest = maxHeap.top();
  maxHeap.pop();
}
std::cout << kthLargest << std::endl;

medium

A. No error, code works correctly

B. Priority queue constructor syntax is incorrect

C. Loop should run k-1 times, not k

D. Must use std::make_heap instead of priority queue

Solution

1. Step 1: Check priority_queue construction

   Constructing maxHeap from vector range is valid and creates max heap.

2. Step 2: Verify loop logic for kth largest

   Loop extracts top element 3 times; last extracted is 3rd largest.

3. Final Answer:

   No error, code works correctly -> Option A

4. Quick Check:

   Priority queue pop k times = kth largest [OK]

Hint: Pop max k times from priority queue to get kth largest [OK]

Common Mistakes:

• Thinking priority_queue constructor is invalid
• Off-by-one error in loop count
• Confusing make_heap and priority_queue usage

5. Given a large array with many duplicate elements, which approach is most efficient to find the 5th largest unique element using a max heap?

hard

A. Use a min heap of size 5 to track unique elements while iterating

B. Sort the array and pick the 5th element from the end

C. Insert all elements into a set, then build a max heap from the set and pop 5 times

D. Build a max heap from the array and pop elements until 5 unique elements are found

Solution

1. Step 1: Efficiency priority

   For large n, O(n log k) is best vs O(n log n); min-heap size k scans once.

2. Step 2: Track unique top-k largest

   Iterate array, maintain min-heap of top 5 uniques (with set for lookup); add if new and > root or size <5, evict root otherwise.

3. Final Answer:

   Use a min heap of size 5 to track unique elements while iterating -> Option A

4. Quick Check:

   Min-heap size k + set = O(n log k) kth unique largest [OK]

Hint: Min heap size k + seen set for kth distinct largest O(n log k) [OK]

Common Mistakes:

• Full max heap pop until k unique (worst O(n log n) with dup leaders)
• Set first: O(n log n) time/space
• Sorting without explicit dedup logic