Kth Largest Element in a Stream - Practice Coding Problems

Kth Largest Element in a Stream - Problem

Imagine you're working for a university admissions office during application season. As test scores stream in real-time, you need to continuously track the k-th highest score to determine admission cutoffs dynamically.

Your task is to implement a KthLargest class that efficiently maintains this information:

Constructor: KthLargest(int k, int[] nums) - Initialize with the value k and an initial array of scores
Add Method: int add(int val) - Add a new score and return the current k-th largest score

The key challenge is that you need to return the k-th largest element after each addition, not just once. This requires an efficient data structure that can handle frequent insertions while quickly retrieving the k-th largest element.

Example: If k=3 and you have scores [4, 5, 8, 2], the 3rd largest is 4. When you add 3, the new 3rd largest becomes 4. When you add 5, it becomes 5.

Input & Output

example_1.py — Basic Operations

$ Input: k = 3, nums = [4, 5, 8, 2] Operations: add(3), add(5), add(10), add(9), add(4)

› Output: [4, 5, 5, 8, 8]

💡 Note: Initially, the 3rd largest among [4,5,8,2] is 4. After adding 3: [8,5,4,3,2] → 3rd largest is 4. After adding 5: [8,5,5,4,3,2] → 3rd largest is 5. After adding 10: [10,8,5,5,4,3,2] → 3rd largest is 5. And so on.

example_2.py — Small K Value

$ Input: k = 1, nums = [] Operations: add(-3), add(-2), add(-4), add(0), add(4)

› Output: [-3, -2, -2, 0, 4]

💡 Note: When k=1, we're always looking for the maximum element. Starting with empty array, each add returns the largest element seen so far.

example_3.py — Edge Case with Duplicates

$ Input: k = 2, nums = [0] Operations: add(-1), add(1), add(-2), add(-4), add(3)

› Output: [-1, 0, 0, 0, 1]

💡 Note: With k=2, we track the 2nd largest element. Starting with [0], adding -1 gives [-1,0] so 2nd largest is -1. Adding 1 gives [-1,0,1] so 2nd largest is 0, and so on.

Visualization

Tap to expand

Understanding the Visualization

Initialize VIP List

Start with customers spending [4, 5, 8, 2]. Your VIP section keeps [8, 5, 4] with 4 as the minimum VIP spender.

Customer Spends 3

Customer spending 3 can't displace anyone (3 < 4), so VIP list stays [8, 5, 4]. Minimum VIP spender: 4.

Customer Spends 10

Customer spending 10 displaces the minimum VIP spender (4). New VIP list: [10, 8, 5]. New minimum VIP spender: 5.

Constant Time Updates

With only 3 VIP spots to manage, checking and updating takes constant time, no matter how many total customers you've seen.

Key Takeaway

🎯 Key Insight: By maintaining only the K largest elements in a min-heap, we can efficiently answer "what's the K-th largest?" in O(log K) time, regardless of how many total elements we've processed!

Time & Space Complexity

Time Complexity

⏱️

O(log k)

Each add operation involves at most one heap operation (insert/replace) which takes O(log k)

⚡ Linearithmic

Space Complexity

O(k)

Only store K elements in the min-heap

✓ Linear Space

Constraints

1 ≤ k ≤ 10⁴
0 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
-10⁴ ≤ val ≤ 10⁴
At most 10⁴ calls will be made to add
It is guaranteed that there will be at least k elements in the array when you search for the k^th element.

Asked in

a Amazon 45 G Google 38 f Facebook 32 ⊞ Microsoft 28

The optimal solution uses a min-heap of size K to efficiently track the K-th largest element in a stream. By maintaining exactly K elements in the heap, the root always represents the K-th largest element. Each add operation runs in O(log K) time with O(K) space complexity, making it highly efficient for real-time streaming scenarios.

Common Approaches

Approach	Time	Space	Notes
✓ Min-Heap of Size K (Optimal)	O(log k)	O(k)	Maintain a min-heap containing exactly the K largest elements seen so far
Sorted List with Binary Search	O(n)	O(n)	Maintain a sorted list and use binary search for insertions

Min-Heap of Size K (Optimal) — Algorithm Steps

Initialize a min-heap with the first K largest elements from the initial array
When adding a new element, compare it with the heap root (smallest of K largest)
If new element is larger than root or heap size < K, add/replace in heap
The root of the heap is always the K-th largest element

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heap

Create min-heap with k=3 largest from [4,5,8,2]: heap=[4,5,8]

Add 3

Add 3 to heap, size exceeds k, so remove min. Heap=[4,5,8], root=4

Add 5

Add 5 to heap [4,5,8,5], remove min(4). Heap=[5,5,8], root=5

Add 10

Add 10 to heap [5,5,8,10], remove min(5). Heap=[5,8,10], root=5

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int k;
    int* heap;
    int size;
    int capacity;
} KthLargest;

// Min heap helper functions
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void minHeapify(int* heap, int size, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < size && heap[left] < heap[smallest])
        smallest = left;
    
    if (right < size && heap[right] < heap[smallest])
        smallest = right;
    
    if (smallest != i) {
        swap(&heap[i], &heap[smallest]);
        minHeapify(heap, size, smallest);
    }
}

void heapInsert(int* heap, int* size, int val) {
    (*size)++;
    int i = *size - 1;
    heap[i] = val;
    
    while (i != 0 && heap[(i - 1) / 2] > heap[i]) {
        swap(&heap[i], &heap[(i - 1) / 2]);
        i = (i - 1) / 2;
    }
}

int heapExtractMin(int* heap, int* size) {
    if (*size <= 0) return -1;
    if (*size == 1) {
        (*size)--;
        return heap[0];
    }
    
    int root = heap[0];
    heap[0] = heap[*size - 1];
    (*size)--;
    minHeapify(heap, *size, 0);
    
    return root;
}

KthLargest* kthLargestCreate(int k, int* nums, int numsSize) {
    KthLargest* obj = (KthLargest*)malloc(sizeof(KthLargest));
    obj->k = k;
    obj->capacity = k + 1;
    obj->heap = (int*)malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    
    // Add all initial numbers
    for (int i = 0; i < numsSize; i++) {
        heapInsert(obj->heap, &obj->size, nums[i]);
        if (obj->size > k) {
            heapExtractMin(obj->heap, &obj->size);
        }
    }
    
    return obj;
}

int kthLargestAdd(KthLargest* obj, int val) {
    heapInsert(obj->heap, &obj->size, val);
    
    if (obj->size > obj->k) {
        heapExtractMin(obj->heap, &obj->size);
    }
    
    return obj->heap[0];
}

void kthLargestFree(KthLargest* obj) {
    free(obj->heap);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(log k)

Each add operation involves at most one heap operation (insert/replace) which takes O(log k)

⚡ Linearithmic

Space Complexity

O(k)

Only store K elements in the min-heap

✓ Linear Space

Constraints

1 ≤ k ≤ 10⁴
0 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
-10⁴ ≤ val ≤ 10⁴
At most 10⁴ calls will be made to add
It is guaranteed that there will be at least k elements in the array when you search for the k^th element.

89.3K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Min-Heap of Size K (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler