参考
题目一: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++知识,不明白的点做了简单总结。