150. 逆波兰表达式求值
https://leetcode.cn/problems/evaluate-reverse-polish-notation/
给你一个字符串数组 tokens ,表示一个根据 逆波兰表示法 表示的算术表达式。 请你计算该表达式。返回一个表示表达式值的整数。 注意:
有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数(运算对象)都可以是一个整数或者另一个表达式。
两个整数之间的除法总是向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。**示例 1:
** 输入:tokens = [“2”,“1”,“+”,“3”,“*”]
输出:9 解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9
class Solution {
public:
bool IsDigit(string& s) {
for (int i = 0; i < s.size(); ++i) {
if (i == 0) {
if ((s[i] == '-' && s.size() > 1) || isdigit(s[i])) { // 注意负数的判别
continue;
}
else {
return false;
}
}
if (i > 0 && !isdigit(s[i])) {
return false;
}
}
return true;
}
int evalRPN(vector<string>& tokens) {
stack<int> stk;
for (string s : tokens) {
if (IsDigit(s)) {
stk.push(stoi(s)); // 将数字压入栈
}
else {
int a = stk.top();
stk.pop();
int b = stk.top();
stk.pop();
//计算
int c = 0; // 存储计算结果
if (s == "+") {
c = b + a;
}
else if (s == "-") {
c = b - a;
}
else if (s == "*") {
c = b * a;
}
else if (s == "/") {
c = b / a;
}
//将结果压入栈
stk.push(c);
}
}
return stk.top();
}
};
239. 滑动窗口最大值 (有点难度,可能代码写不出来,但一刷至少需要理解思路)
https://leetcode.cn/problems/sliding-window-maximum/
给你一个整数数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。
示例 1:
输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
输出:[3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
class Solution {
private:
class MyQueue { //单调队列(从大到小)
public:
deque<int> que; // 使用deque来实现单调队列
// 每次弹出的时候,比较当前要弹出的数值是否等于队列出口元素的数值,如果相等则弹出。
// 同时pop之前判断队列当前是否为空。
void pop(int value) {
if (!que.empty() && value == que.front()) {
que.pop_front();
}
}
// 如果push的数值大于入口元素的数值,那么就将队列后端的数值弹出,直到push的数值小于等于队列入口元素的数值为止。
// 这样就保持了队列里的数值是单调从大到小的了。
void push(int value) {
while (!que.empty() && value > que.back()) {
que.pop_back();
}
que.push_back(value);
}
// 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
int front() {
return que.front();
}
};
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
MyQueue que;
vector<int> result;
for (int i = 0; i < k; i++) { // 先将前k的元素放进队列
que.push(nums[i]);
}
result.push_back(que.front()); // result 记录前k的元素的最大值
for (int i = k; i < nums.size(); i++) {
que.pop(nums[i - k]); // 滑动窗口移除最前面元素
que.push(nums[i]); // 滑动窗口前加入最后面的元素
result.push_back(que.front()); // 记录对应的最大值
}
return result;
}
};
347.前 K 个高频元素
https://leetcode.cn/problems/top-k-frequent-elements/
给你一个整数数组 nums 和一个整数 k ,请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
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) {
// map统计元素出现频率
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;
}
};
优先队列 priority_queue
priority_queue 为队列中的元素建立优先级,新加入的元素会排在所有优先级比它低的元素之前(大根堆)
priority_queue<Type, Container, Functional>;
Type
是要存放的数据类型
Container
是实现底层堆的容器,必须是数组实现的容器,如vector、deque
Functional
是比较方式/比较函数/优先级
pq.pop(); //返回priority_queue的最高优先级元素
pq.top(); //返回最高优先级元素
pq.push(item);//在priority_queue优先级合适的位置创建元素
pq.empty(); //priority_queue是否为空
pq.size(); //返回priority_queue内元素个数
pq.emplace(args); //原地构造一个元素并插入队列
小顶堆
priority_queue<int, vector<int>, greater<int>> pq; //小顶堆
pq.push(2); p.push(1); pq.push(3);
while (pq.empty() == false) { //输出 1 2 3
cout << pq.top() << " ";
pq.pop();
}
大顶堆
priority_queue<int, vector<int>, less<int>> pq;
//priority_queue<int> pq //默认大顶堆
pq.push(2); pq.push(1); pq.push(3);
while (pq.empty() == false) { //输出 3 2 1
cout << pq.top() << " ";
pq.pop();
}
默认大顶堆
priority_queue<int> pq;
pair
priority_queue<pair<int, int> > pq;
pair<int, int> a(1, 2);
pair<int, int> b(3, 4);
pair<int, int> c(1, 5);
pq.push(a);
pq.push(b);
pq.push(c);
while (!pq.empty())
{
cout << pq.top().first << ' ' << pq.top().second << '\n';
pq.pop();
}
//输出结果为:
3 4
1 5
1 2
自定义比较方式
当数据类型不是基本数据类型,而是自定义的数据类型时,就不能使用greater或less的比较方式了,而需要自定义比较方式;
有两种自定义比较方式的方法,分别是:1.重载运算符 重载”<”;2.重写仿函数
#include <iostream>
#include <queue>
using namespace std;
//方法一:重载<运算符,queue定义不变,的优先级设置
class fruit{
public:
string name;
int price;
//friend bool operator > (fruit f1,fruit f2){ //重载>大于号会编译报错
friend bool operator < (fruit f1,fruit f2){
return f1.price<f2.price; //相当于默认大根堆,就是没改变<的含义,那就相当于是优先队列默认模式那就是大根堆
return f1.price>f2.price; //相当于小根堆,就是改变<的含义,那就相当于改变优先队列默认模式那就是小根堆
}
};
//方法二:重写仿函数
class cmp{
public:
bool operator () (fruit f1,fruit f2){
return f1.price>f2.price; //相当于小根堆,就是改变<的含义,那就相当于改变优先队列默认模式那就是小根堆
return f1.price<f2.price; //相当于默认大根堆,就是没改变<的含义,那就相当于是优先队列默认模式那就是大根堆
}
};
int main()
{
//方法一:
priority_queue<fruit> p;
p.push(fruit{"aaa",2});
p.push(fruit{"bbb",1});
p.push(fruit{"ccc",3});
cout<<p.top().name<<" "<<p.top().price<<endl; //输出:ccc 3
//方法二:
priority_queue<fruit,vector<fruit>,cmp> p1;
p1.push(fruit{"aaa",2});
p1.push(fruit{"bbb",1});
p1.push(fruit{"ccc",3});
cout<<p1.top().name<<" "<<p1.top().price<<endl; //输出:bbb 1
return 0;
}