Kth Largest Element in a Stream

Problem

Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Implement KthLargest class:

• KthLargest(int k, int[] nums) Initializes the object with the integer k and the stream of integers nums.
• int add(int val) Appends the integer val to the stream and returns the element representing the kth largest element in the stream.

Example 1:

Input
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
Output
[null, 4, 5, 5, 8, 8]

Explanation
KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
kthLargest.add(3);   // return 4
kthLargest.add(5);   // return 5
kthLargest.add(10);  // return 5
kthLargest.add(9);   // return 8
kthLargest.add(4);   // return 8

Intuition

The problem involves finding the kth largest element in a stream of integers. To efficiently maintain the kth largest elements, we can use a min-heap. The heap will store the k largest elements, and the root of the heap will always represent the kth largest element.

Approach

Initialization (init):

The constructor init initializes the KthLargest object with the integer k and the stream of integers nums.
A min-heap (minheap) is created using the nums array, and heapq.heapify is used to convert the array into a heap. The size of the heap is limited to k elements. If the heap size exceeds k, elements are popped from the heap until the size becomes k.
Adding an Element (add):

The add method appends the integer val to the stream and returns the element representing the kth largest element in the stream.
The new element is added to the min-heap using heapq.heappush.
If the size of the heap exceeds k after adding the new element, the smallest element is removed from the heap using heapq.heappop.
The root of the min-heap (minheap[0]) represents the kth largest element.

Complexity

• Time complexity:

The time complexity for adding an element is O(log k), where k is the size of the min-heap. This is because both the heapq.heappush and heapq.heappop operations take O(log k) time.

• Space complexity:

The space complexity is O(k) for maintaining the min-heap, where k is the size of the heap.

Code

class KthLargest:

    def __init__(self, k: int, nums: List[int]):
        self.minheap, self.k = nums, k
        heapq.heapify(self.minheap)
        while len(self.minheap) > k:
            heapq.heappop(self.minheap)

    def add(self, val: int) -> int:
        heapq.heappush(self.minheap, val)
        if len(self.minheap) > self.k:
            heapq.heappop(self.minheap)
        return self.minheap[0]


# Your KthLargest object will be instantiated and called as such:
# obj = KthLargest(k, nums)
# param_1 = obj.add(val)