数据流中的第 K 大元素

设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。

请实现 KthLargest 类：KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。
int add(int val) 将 val 插入数据流 nums 后，返回当前数据流中第 k 大的元素。

如下：

输入：
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
输出：
[null, 4, 5, 5, 8, 8]

解释：
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

当我们要找一个数据流中的最大值时还是比较简单的，我们可以用一个变量存储最大值，当来一个值时和最大值进行比较，如果比最大值大，则替换最大值，如果比最大值小，则不做任何处理，这样我们就可以获得数据流中的最大值。

//核心代码
int maxValue = Integer.MIN_VALUE;

//当数据流中的一个值进入时
if(data > maxValue)
{    
    maxValue = data;
}

那对于求数据流中的第k大元素，其实道理也是类似的，如果我们把前k大的元素存储起来，那这k个元素中最小的一个元素，即为第k大元素。那可以按照如下的方向进行思考，可以用一个数组存储前k大的元素，可以把元素进行排序存储。如果使用快速排序，排序的时间复杂度就是O(Klgk)

当数据流中的一个一个元素进入时，如果数组中的元素小于k个，那添加入存储结果中，同时进行排序，那对于每一个元素都需要进行如此操作，最中的时间复杂度就是O(NKlgk)，代码如下。

package Ycb;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class KthLargest {
    private List<Integer> stores;
    private int k;

    public KthLargest(int k, int[] nums) {
        this.k = k;
        //初始化存储数组
        stores = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            stores.add(nums[i]);
        }

        //按照降序排序
        stores.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        //如果stores中元素的个数大于k，则需要移除，保证stores中存储的元素个数小于等于k
        if (stores.size() > k) {
            for (int i = stores.size() - 1; i > k - 1; i--) {
                stores.remove(i);
            }
        }
    }

    public int add(int val) {
        if (stores.size() < k) {
            stores.add(val);
        } else if (val > stores.get(stores.size() - 1)) {
            stores.remove(stores.size() - 1);
            stores.add(val);
        }
        //按照降序排序
        stores.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        return stores.get(stores.size() - 1);
    }
}

从以上的逻辑中可以看出，每一个元素加入到数组中之后对需要对stores中的元素进行排序，其实可以对这一部分进行优化，优先级队列就可以解决这个问题。

可以使用一个小顶堆代替数组，当来一个元素时，如果比堆顶还小，则直接抛弃，如果比堆顶元素大，则把堆顶元素移除，同时把元素放入堆中，再执行堆化等等操作。分析清楚问题之后代码就比较简单了，直接给出代码

package Ycb;

import java.util.PriorityQueue;

public class KthLargest {
    final PriorityQueue<Integer> priorityQueue;
    final int k;

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

    public int add(int val) {
        //说明堆中的元素还没有到达k，直接添加进入堆即可
        if (priorityQueue.size() < k) {
            priorityQueue.offer(val);
        } else if (priorityQueue.peek() < val) {
            priorityQueue.poll();
            priorityQueue.offer(val);
        }
        return priorityQueue.peek();
    }
}