leetcode.703(数据流中第K大元素)

题目：
设计一个找到数据流中第K大元素的类（class）。注意是排序后的第K大元素，不是第K个不同的元素。
你的 KthLargest 类需要一个同时接收整数 k 和整数数组nums 的构造器，它包含数据流中的初始元素。每次调用 KthLargest.add，返回当前数据流中第K大的元素。
示例:
int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3); // returns 4
kthLargest.add(5); // returns 5
kthLargest.add(10); // returns 5
kthLargest.add(9); // returns 8
kthLargest.add(4); // returns 8

方法一：
维持一个大小为K的有序数组（从大到小）有几种情况要考虑：

1. 如果arr.size()<K：当执行add时，直接将val放到数组里，并将排序后的数组的最后一个数作为返回值
2. 如果arr.size()>=K：
   1）后面进来的元素比nums[k-1]小，直接return nums[k-1]
   2）后面进来得元素比nums[k-1]大，将数组最后一个数pop出去，然后将val放到数组里，并将排序后的数组的最后一个数作为返回值

代码如下：但是有一个k=9999的测试用例会超时

class KthLargest {
public:
    int min(int a,int b){
        if(a<=b)return a;
        else return b;
    }
    KthLargest(int k, vector<int>& nums) {
        size_k=k;
        if(nums.size()!=0)
            sort(nums.begin(),nums.end(),greater<int>());
        for(int i=0;i<min(k,nums.size());i++){
             tree.push_back(nums[i]);
        }
    }
    
    int add(int val) {
            if(tree.size()<size_k){
            tree.push_back(val);
            sort(tree.begin(),tree.end(),greater<int>());
            return tree[size_k-1];
        }
        else {
        	if(val<=tree[size_k-1])
           		return tree[size_k-1];
        	else 
        	{
            	tree.pop_back();
            	tree.push_back(val);
            	sort(tree.begin(),tree.end(),greater<int>());
            	return tree[size_k-1];
        	}
        }
    }
    private:
        vector<int>tree;
        int size_k;
};

方法二：
基本思想与方法一相同。不同的是，将数组换成优先队列

优先队列的出队顺序是按照优先级来的
支持插入和删除最大/最小元素
一般用于找到元素集合中的最小或最大元素

代码如下：

class KthLargest {
public:
    KthLargest(int k, vector<int>& nums) {
        size_k=k;
        for(int i=0;i<nums.size();i++){
             tree.push(nums[i]);
        }
        if(nums.size()>k){
            for(int j=0;j<(nums.size()-k);j++){
                tree.pop();
            }
        }     
    }
    
    int add(int val) {
        //int size_k=tree.size();
        if(tree.size()<size_k){
            tree.push(val);  
            return tree.top();
        }
        else {
            if(val<=tree.top())
                return tree.top();
            else 
            {
                tree.pop();
                tree.push(val);
                return tree.top();
            }
        }
    }
    private:
        priority_queue<int,vector<int>,greater<int>>tree;//维护一个小顶堆
        int size_k;
};