leetcode-703-easy

Kth Largest Element in a Stream

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
Constraints:

1 <= k <= 104
0 <= nums.length <= 104
-104 <= nums[i] <= 104
-104 <= val <= 104
At most 104 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 kth element.

思路一：刚开始用链表实现，插入是遍历查找对比后插入，发现超时了。然后用二分法改进插入的算法，发现还是超时。

    public KthLargest(int k, int[] nums) {
        this.k = k;
        Arrays.sort(nums);
        for (int num : nums) {
            list.add(num);
        }
    }

    public int add(int val) {
        int low = 0;
        int high = list.size() - 1;
        int mid = 0;

        while (low < high) {
            mid = low + (high - low) / 2;

            if (list.get(mid) == val) {
                low = mid;
                break;
            } else if (list.get(mid) > val) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        if (list.size() > 0 && list.get(low) < val) {
            list.add(low + 1, val);
        } else {
            list.add(low, val);
        }

        return list.get(list.size() - k);
    }

思路二：看了一下官方解答，用一个优先队列维护 k 个数字，对于小于第 k 个数字的值，直接抛弃

    PriorityQueue<Integer> queue;
    private int k;

    public KthLargest(int k, int[] nums) {
        this.k = k;
        queue = new PriorityQueue<>();
        for (int num : nums) {
            add(num);
        }
    }

    public int add(int val) {
        queue.offer(val);
        if (queue.size() > k) {
            queue.poll();
        }
        return queue.peek();
    }