Kth Largest Element in a Stream

Kth Largest Element in a Stream - Problem

You are part of a university admissions office and need to keep track of the kth highest test score from applicants in real-time. This helps to determine cut-off marks for interviews and admissions dynamically as new applicants submit their scores.

You are tasked to implement a class which, for a given integer k, maintains a stream of test scores and continuously returns the kth highest score after a new score has been submitted.

More specifically, we are looking for the kth highest score in the sorted list of all scores.

Implement the KthLargest class:

KthLargest(int k, int[] nums) - Initializes the object with the integer k and the stream of test scores nums
int add(int val) - Adds a new test score val to the stream and returns the element representing the kth largest element in the pool of test scores so far

Input & Output

Example 1 — 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: Initial: [8,5,4] are 3 largest. Add 3→4th largest is 4. Add 5→still 4. Add 10→now 5. Add 9→now 8. Add 4→still 8.

Example 2 — Minimum Size

$ Input: k = 1, nums = [1], operations = [["add",2],["add",0]]

› Output: [2,2]

💡 Note: k=1 means always return the maximum. After adding 2, max is 2. After adding 0, max is still 2.

Example 3 — Empty Initial Array

$ Input: k = 2, nums = [], operations = [["add",5],["add",3],["add",7]]

› Output: [5,3,5]

💡 Note: Add 5: only element so 2nd largest is 5. Add 3: 2nd largest is 3. Add 7: 2nd largest becomes 5.

Constraints

1 ≤ k ≤ 10⁴
0 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
-10⁴ ≤ val ≤ 10⁴
At most 10⁴ calls will be made to add

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Facebook 8 Apple 6

The key insight is to maintain only the k largest elements using a min-heap. The root of this heap is always the kth largest element. Best approach is the Min-Heap solution with Time: O(log k) per add operation, Space: O(k).

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Dp 2d

⏱️ Time: N/A Space: N/A

Brute Force - Sort Every Time

⏱️ Time: O(n log n) Space: O(n)

Store all scores in a list. When adding a new score, append it to the list, sort the entire list in descending order, and return the kth element (index k-1).

Min-Heap of Size K

⏱️ Time: O(log k) Space: O(k)

Maintain a min-heap of size k. The root of this heap is always the kth largest element. When adding a new element, if heap size < k, add it. If the new element is larger than the root, replace the root.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int memo[1000];
int memoEnding[1000];
int coords[1000][2];
int n;

int max(int a, int b) {
    return a > b ? a : b;
}

int getLIS(int startIdx) {
    if (memo[startIdx] != -1) return memo[startIdx];
    
    int result = 1;
    int x = coords[startIdx][0], y = coords[startIdx][1];
    
    for (int i = 0; i < n; i++) {
        if (i != startIdx) {
            int nx = coords[i][0], ny = coords[i][1];
            if (nx > x && ny > y) {
                result = max(result, 1 + getLIS(i));
            }
        }
    }
    
    memo[startIdx] = result;
    return result;
}

int getLISEnding(int endIdx) {
    if (memoEnding[endIdx] != -1) return memoEnding[endIdx];
    
    int result = 1;
    int x = coords[endIdx][0], y = coords[endIdx][1];
    
    for (int i = 0; i < n; i++) {
        if (i != endIdx) {
            int nx = coords[i][0], ny = coords[i][1];
            if (nx < x && ny < y) {
                result = max(result, 1 + getLISEnding(i));
            }
        }
    }
    
    memoEnding[endIdx] = result;
    return result;
}

int solution(int coordinates[][2], int size, int k) {
    n = size;
    for (int i = 0; i < n; i++) {
        coords[i][0] = coordinates[i][0];
        coords[i][1] = coordinates[i][1];
        memo[i] = -1;
        memoEnding[i] = -1;
    }
    
    int pathFromK = getLIS(k);
    int pathToK = getLISEnding(k);
    
    return max(max(pathFromK, pathToK), pathToK + pathFromK - 1);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int k;
    scanf("%d", &k);
    
    int coordinates[1000][2];
    int count = 0;
    char* ptr = line + 1;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            coordinates[count][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            coordinates[count][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++;
            count++;
        }
        ptr++;
    }
    
    printf("%d\n", solution(coordinates, count, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

High Frequency

~25 min Avg. Time

4.2K 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