参考
题目一：LeetCode 239.滑动窗口最大值
这个题之前没有做过，如果直接用暴力求解的话必定超时，除此之外想不到其他求解方法。代码随想录里用的单调队列，看了题解还是很好理解的，记录一下自己的理解。
假设数组nums = [1,3,1,2,0,5]，k = 3，要维护一个单调队列，从front到back是单调递减的，窗口中的最大值总是在队列的front位置，每次往队列中放入数据都要和队列的back元素比较，以保证单调性（注意这里是和back位置的元素比较，而不是front位置）。单调队列用C++里的双端队列deque构建。
- 创建滑动窗口
第一个数为1，此时单调队列为空，直接添加元素。第二个数为3，和单调队列的back元素1比较，由于3>1，所以弹出1，放入3。第三个数为1，和和单调队列的back元素3比较，由于3>1，所以直接将1放入队列中。至此，滑动窗口创建完成，滑动窗口中的最大值为3，如下图所示：
- 向右移动窗口，此时窗口中丢弃数值1，丢弃的数值1不是目前的最大值3，所以不用弹出；新添加的数值为2，由于2要比队列back位置处的1大，所以将1从back处弹出，2小于3，所以将2添加到队列中，此时滑动窗口的最大值为3，如下图所示：
- 继续向右移动窗口，此时丢弃的数值为3，正好是当前的最大值，所以要将3从队列中弹出；新添加的数值为0，比队列的back位置处的2要小，所以直接将0添加到队列中，此时的最大值为2，如下图所示：
- 继续向右移动窗口，此时丢弃的数值为1，不等于当前的最大值2，所以不用将最大值2弹出；新添加的元素为5，与队列back位置进行比较，由于5比0和2都大，所以将0和2都弹出，将5加入对立队列中，此时的最大值为5，如下图所示：
这样就遍历完成了。从上面的过程可以看出，这个单调队列的数值从front到back始终是单调递减的，最大值始终在front位置处，每次移动窗口，要判断从窗口中移除的元素是否为最大值，若是则需要将最大值从队列中弹出，若不是则不需要；每次移动窗口，新添加的元素要与back位置处的元素进行比较，直到新添加的元素比back位置处的元素数值小。可以看出，用双端队列的原因是，从front位置弹出最大值，从back位置弹出比新元素小的元素，这样这个队列就能始终保持单调递减了。代码实现如下：
class Solution {
public:
void pop(int val) // 弹出滑动窗口最左边的值
{
if(val == que.front())
que.pop_front();
}
void push(int val) //往滑动窗口里添加新值
{
while(!que.empty() && que.back() < val) que.pop_back();
que.push_back(val);
}
int getMaxValue() //获取滑动窗口中的最大值
{
return que.front();
}
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
vector<int> result;
/* 创建滑动窗口 */
for(int i=0;i<k;i++) push(nums[i]);
/* 获取最大值 */
result.push_back(getMaxValue());
/* 向右移动滑动窗口 */
for(int i=k;i<nums.size();i++)
{
pop(nums[i-k]); // 移除滑动窗口最左边的值
push(nums[i]); //往滑动窗口里添加新值
result.push_back(getMaxValue()); //获取滑动窗口里的最大值
}
return result;
}
private:
deque<int> que;
};
注意，代码中的pop和push是针对滑动窗口而言的，不要与队列的两个函数混淆。
二刷代码补充：
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
deque<int> deq;
vector<int> vec;
//创建滑动窗口，初始化单调队列
for(int i = 0; i < k - 1; i++){
while(!deq.empty() && nums[i] > deq.back()) deq.pop_back(); //弹出比当前元素小的元素
deq.push_back(nums[i]);
}
for(int i = k - 1; i < nums.size(); i++) {
while(!deq.empty() && nums[i] > deq.back()) deq.pop_back(); //弹出比当前元素小的元素
deq.push_back(nums[i]); //添加当前元素
vec.push_back(deq.front()); //添加记录当前窗口中的最大值
if(deq.front() == nums[i - k + 1]) //如果最大值已经不在窗口中，则需要将最大值从单调队列中弹出
deq.pop_front();
}
return vec;
}
};
题目二：LeetCode 347.前 K 个高频元素
这个题看了题目之后的想法是哈希+快排，具体做法是用map来统计每个数值出现的次数，数值作为key，次数作为value，然后对value进行排序即可，这种解法的时间复杂度是O(nlong)。但这里是栈与队列的专题，所以应该有更好的解法。代码随想录里给出的做法是用优先级队列（小顶堆）来找到前k个高频元素而不需要对全部进行排列。
什么是优先级队列
在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。通常采用堆数据结构来实现。
什么是堆
堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。
C++里提供了优先级队列priority_queue，可以直接用它来实现堆。代码随想录给出的代码如下：
// 时间复杂度：O(nlogk)
// 空间复杂度：O(n)
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; // map<nums[i],对应出现的次数>
for (int i = 0; i < nums.size(); i++) {
map[nums[i]]++;
}
// 对频率排序
// 定义一个小顶堆，大小为k
priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
// 用固定大小为k的小顶堆，扫面所有频率的数值
for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
pri_que.push(*it);
if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
pri_que.pop();
}
}
// 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
vector<int> result(k);
for (int i = k - 1; i >= 0; i--) {
result[i] = pri_que.top().first;
pri_que.pop();
}
return result;
}
};
代码的实现思路很好理解，但是里面一些C++的东西不太明白，这里补充一下。
priority_queue
template<
class T,
class Container = std::vector<T>,
class Compare = std::less<typename Container::value_type>
> class priority_queue;
- T - 存储的元素类型
- Container - 用于存储元素的底层容器类型
- Compare - 提供严格弱序的比较 (Compare) 类型。注意比较 (Compare) 形参的定义，使得若其第一参数在弱序中先于其第二参数则返回 true 。但因为 priority_queue 首先输出最大元素，故“先来”的元素实际上最后输出。即队列头含有按照比较 (Compare) 所施加弱序的“最后”元素。
pair
功能：pair将一对值(T1和T2)组合成一个值，这一对值可以具有不同的数据类型（T1和T2），两个值可以分别用pair的两个公有函数first和second访问。
pair<int,double> p(3,3.14);
cout << p.first << endl;
cout << p.second << endl;
operator
参考：https://zhuanlan.zhihu.com/p/353189480
c++ 中的operator()有两大主要作用：
- Overloading： 重载()操作符
- Casting ：实现对象类型转化
1）Overloading： 重载()操作符
class maxValue
{
public:
int operator() (int& a,int& b)
{
return a > b ? a : b;
}
};
int main()
{
int a = 3,b = 4;
maxValue getMax;
cout << "max = " << getMax(a,b) << endl; //输出4
return 0;
}
题解中给出的用法就是这种。
2）Casting ：实现对象类型转化
class testClass
{
public:
double val = 3.14;
operator int()
{
return val;
}
};
int main()
{
testClass test;
cout << test << endl; //输出3
return 0;
}
哈希+快排的实现：
class Solution {
public:
static bool cmp(pair<int, int> a, pair<int, int> b)
{
return a.second > b.second;
}
vector<int> topKFrequent(vector<int>& nums, int k) {
unordered_map<int, int> umap;
vector<int> result;
for(int i = 0; i < nums.size(); i++)
umap[nums[i]]++;
vector<pair<int, int>> vec(umap.begin(), umap.end());
sort(vec.begin(), vec.end(), cmp);
for(int i = 0; i < k; i++)
result.push_back(vec[i].first);
return result;
}
};
今日小结
今天的题有一定难度，但是看了题解还是很好理解的，一个题用的是单调队列，一个题用的优先级队列（小顶堆），思路不难理解，但第二题给出的代码里有些不明白的C++知识，不明白的点做了简单总结。
762
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
