代码随想录算法训练营第十三天|239.滑动窗口最大值 347.前 K 个高频元素

目录

LeeCode 239.滑动窗口最大值 

LeeCode 347.前 K 个高频元素 

---

LeeCode 239.滑动窗口最大值 

力扣题目链接

思路：实现一个单调队列，保证队首元素始终为当前滑动窗口的最大值。

设计单调队列的时候，pop，和push操作要保持如下规则：

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。

个人理解：

首先将前k个元素依次进行入队操作，若插入元素大于前面元素，就删除前面元素。

窗口移动时，若移除的元素是队首元素，就将其弹出，若不是，说明这个元素因为较小已经被移出队列了，就不用再管它。插入元素时，若插入的元素大于前面元素，删除前面元素。

这样，队首元素就是当前滑动窗口的最大值，将它放到另一个数组容器中保存。

class Solution {
private:
    class MyQueue {
    public:
    	deque<int> que;
    	void pop(int value) {
    		if (!que.empty() && value == que.front()) {
    			que.pop_front();
			}
		}
		void push(int value) {
			while (!que.empty() && value > que.back()) {
				que.pop_back();
			}
			que.push_back(value);
		}
		int front() {
			return que.front();
		}
	}; 
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    	MyQueue que;
    	vactor<int> result;
    	for (int i = 0; i < k; i++) {
    		que.push(nums[i]);
		}
		result.push_back(que.front());
		for (int i = k; i < nums.size(); i++) {
			que.pop(nums[i - k]);
			que.push(nums[i]);
			result.push_back(que.front());
		}
		return result;
    }
};

 时间复杂度：O(n)        空间复杂度：O(k)

---

LeeCode 347.前 K 个高频元素 

力扣题目链接

思路：用map统计元素出现频率，使用优先级队列对频率排序，找出前k个高频元素。

class Solution {
public:
	class mycomparison {
    public:
    	bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
    		return lhs.second > rhs.second;
		}
	};
    vector<int> topKFrequent(vector<int>& nums, int k) {
    	unordered_map<int, int> map;
    	for (int i = 0; i < nums.size(); i++) {
    		map[nums[i]]++;
		}
    	priority_queue<pair<int,int>, vector<pair<int, int>>, mycomparison> pri_que;
		for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
			pri_que.push(*it);
			if (pri_que.size() > k) {
				pri_que.pop();
			}
		}
		vector<int> result(k);
		for (int i = k - 1; i>= 0; i--) {
			result[i] = pri_que.top().first;
			pri_que.pop();
		}
        return result;
    }
};

 时间复杂度：O(nlogn)        空间复杂度：O(n)