#leetCode刷题纪实 Day11

https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/submissions/

设计一个找到数据流中第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
说明:
你可以假设 nums 的长度≥ k-1 且k ≥ 1。

 

小菜鸡的尝试：

因为c++学的不是很好，所以类的编程写得磕磕巴巴的。虽然用了优先队列，但还是超时了，我寻思可能是因为对于每个add操作都是O（n）复杂度的pop()。于是想着，能不能对于每个add操作都是O（1）

 

class KthLargest {
public:
    int k;
    priority_queue<int> que;
    KthLargest(int k, vector<int>& nums) {
        // 构造优先队列
        priority_queue<int> que;
        for (int i = 0; i < nums.size(); i ++) {
            que.push(nums[i]);
        }
        // 成员函数setter
        this -> k = k;
        this -> que = que;
    }

    int add(int val) {
        priority_queue<int> que = this -> que;
        que.push(val);
        this -> que = que;
        priority_queue<int> que0 = que;
        int k = this -> k;
        for (int i = 0; i < k - 1; i ++) {
            que0.pop();
        }
        return que0.top();
    }
};

 

优化后的方案：因为要求第K大的数，因此比当前第K大的数小的数是我们不需要考虑的，我们只需要面对比当前第K大的数大的数进行思考即可。

因此：优先队列中不需要存储比当前第K大的数小的数，队列的头就是第K大的数。如果下一个add的数是小于队列头的数，则不需要进行处理，直接返回队头。如果下一个add的数是大于队列的头，则入队，再弹出此时队列的头。返回弹出后队列的头。（至此就是最基本的思路）

　　当然这样的代码是不健壮的（我怎么知道？因为我不停地在被数据集WA啊）【举个栗子，如果我要求第三大的数，但我初始化的数据只有两个，那么无论此时add的数是大是小，他就应该是第三大的数！awsl】

class KthLargest {
public:
    int k;
    int num;
    priority_queue<int, vector<int>, greater<>> que;
    int length;
    KthLargest(int k, vector<int>& nums) {
        // 构造优先队列
        priority_queue<int, vector<int>, greater<>> queue;
        int num = INT_MAX;
        if (nums.empty()) {
            this -> que = queue;
            this -> num = num;
            this -> length = 0;
            this -> k = k;
        } else {
            int size = nums.size();
            for (int i = 0; i < size; i ++) {
                queue.push(nums[i]);
            }
            for (int i = 0; i < size - k; i ++) {
                queue.pop();
            }
            int num = queue.top();
            // 成员函数
            this -> num = num;
            this -> que = queue;
            this -> length = size;
            this -> k = k;
        }
    }

    int add(int val) {
        priority_queue<int, vector<int>, greater<>> queue = this -> que;
        int i = this -> num;
        int length = this -> length;
        int k = this -> k;
        if (i == INT_MAX) {
            i = val;
            queue.push(val);
            this -> que = queue;
            this -> num = i;
            this -> length = ++ length;
            return i;
        }
        if (++ length == k) {
            queue.push(val);
            this -> que = queue;
            this -> length = ++ length;
            return queue.top();
        }
        if (val < i) {
            this -> length = ++ length;
            return i;
        }
        queue.push(val);
        queue.pop();
        this -> que = queue;
        this -> num = queue.top();
        this -> length = ++ length;
        return queue.top();
    }
};

 

膜拜大佬代码：

一样的思路，但人大佬的代码就！简洁美观！言简意赅！！

class KthLargest {
public:
    priority_queue<int, vector<int>, greater<int>> pq;
    int size;

    KthLargest(int k, vector<int> nums) {
        size=k;//将小根堆的大小控制在k
        for(int i=0;i<nums.size();i++) {
            pq.push(nums[i]);
            if(pq.size()>k) pq.pop();
        }
    }
    
    int add(int val) {
        pq.push(val);
        if(pq.size()>size) pq.pop();
        return pq.top();
    }
};

 

 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/kth-largest-element-in-a-stream
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。