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 integerk
and the stream of integersnums
.int add(int val)
Appends the integerval
to the stream and returns the element representing thekth
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)