代码随想录day11 | LeetCode150. 逆波兰表达式求值、LeetCode239. 滑动窗口最大值、LeetCode347. 前 K 个高频元素
逆波兰表达式求值
自己敲
注意:题中给的是vector<string>
类型,一个token[i]
表示一个字符串(虽然里面仅有一个字符)
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<string> st;
int result=0;
for(int i;i<tokens.size();i++){
if(tokens[i]>="0"&&tokens[i]<="9"){
st.push(tokens[i]);
}else{
string tmp = st.top();
st.pop();
result+=value(tokens[i],st.top(),tmp);
st.pop();
}
}
return result;
}
int value(string s,string a,string b){
if(s=="+"){
return (a-"0")+(b-"0");
}else if(s=="-"){
return (a-"0")-(b-"0");
}else if(s=='*'){
return (a-"0")*(b-"0");
}else{
return (a-"0")/(b-"0");
}
}
};
想了想字符串并不能像普通char类型一样用这种方式int化
查资料得到stoi()
函数可以将string转换成int类型
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
int result=0;
for(int i;i<tokens.size();i++){
if(tokens[i]>="0"&&tokens[i]<="9"){
st.push(stoi(tokens[i]));
}else{
int tmp = st.top();
st.pop();
result=value(tokens[i],st.top(),tmp);
st.pop();
st.push(result);
}
}
return st.top();
}
int value(string s,int a,int b){
if(s=="+"){
return a+b;
}else if(s=="-"){
return a-b;
}else if(s=="*"){
return a*b;
}else{
return a/b;
}
}
};
#include<iostream>
#include<vector>
#include<string>
#include<stack>
using namespace std;
class Solution {
public:
int static evalRPN(vector<string>& tokens) {
stack<int> st;
int result=0;
for(int i;i<tokens.size();i++){
if(tokens[i]>="0"&&tokens[i]<="9"){
st.push(stoi(tokens[i]));
}else{
int tmp = st.top();
st.pop();
result=value(tokens[i],st.top(),tmp);
cout<<result<<"="<<st.top()<<tokens[i]<<tmp<<endl;
st.pop();
st.push(result);
}
}
cout<<"--------------"<<endl;
// cout<<st.top();
return st.top();
}
int static value(string s,int a,int b){
if(s=="+"){
return a+b;
}else if(s=="-"){
return a-b;
}else if(s=="*"){
return a*b;
}else{
return a/b;
}
}
};
int main(){
vector<string> tokens;
tokens.push_back("2");
tokens.push_back("1");
tokens.push_back("+");
tokens.push_back("3");
tokens.push_back("*");
cout<<Solution::evalRPN(tokens);
return 0;
}
在本地运行没有问题,不知道LeetCode为什么错
最后发现错误出在for(int i;i<tokens.size();i++)
此处循环开始条件给i赋值
修改代码如下
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
int result=0;
for(int i=0;i<tokens.size();i++){
if(tokens[i]>="0"&&tokens[i]<="9"){
st.push(stoi(tokens[i]));
}else{
int tmp = st.top();
st.pop();
result=value(tokens[i],st.top(),tmp);
st.pop();
st.push(result);
}
}
return st.top();
}
int value(string s,int a,int b){
if(s=="+"){
return a+b;
}else if(s=="-"){
return a-b;
}else if(s=="*"){
return a*b;
}else{
return a/b;
}
}
};
翻译:类型“int”的地址0xbebebebebebec0ba未对齐,这需要 4 字节对齐 (stl_deque.h),然后你对这个未对齐的地址绑定了引用
查阅资料得知
stack
为空时访问了top
或者时别的原因
暂时未解决
看题解
什么是逆波兰表达式
逆波兰表达式:是一种后缀表达式,所谓后缀就是指运算符写在后面。
平常使用的算式则是一种中缀表达式,如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点:
- 去掉括号后表达式无歧义,上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
- 适合用栈操作运算:遇到数字则入栈;遇到运算符则取出栈顶两个数字进行计算,并将结果压入栈中。
思路
如动画所示:
class Solution {
public:
int evalRPN(vector<string>& tokens) {
// 力扣修改了后台测试数据,需要用longlong
stack<long long> st;
for (int i = 0; i < tokens.size(); i++) {
if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
long long num1 = st.top();
st.pop();
long long num2 = st.top();
st.pop();
if (tokens[i] == "+") st.push(num2 + num1);
if (tokens[i] == "-") st.push(num2 - num1);
if (tokens[i] == "*") st.push(num2 * num1);
if (tokens[i] == "/") st.push(num2 / num1);
} else {
st.push(stoll(tokens[i]));
}
}
int result = st.top();
st.pop(); // 把栈里最后一个元素弹出(其实不弹出也没事)
return result;
}
};
总结
- 思路没啥难度,留心细节
vector<string>& tokens
用字符串存单个字符,不是我们平常理解的用char
存单个字符 - 什么叫 力扣修改了后台测试数据,需要用longlong? 我的代码提交给LeetCode还是过不了
滑动窗口最大值
题目链接:LeetCode239. 滑动窗口最大值
自己敲
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
queue<int> qu;
for(int i=0;i<k;i++){//先做一个窗口
qu.push(nums[i]);
}
vector<int> result;
result.push_back(queueMax(qu,k));
int j;//每轮滑动窗口新加入的元素下标
if(k<nums.size()){
j=nums.size();
}else{
j=k;
}
for(int i=0;i<nums.size()-k+1;i++){//滑动窗口右移
qu.pop();
qu.push(nums[j++]);
result.push_back(queueMax(qu,k));
}
return result;
}
int queueMax(queue<int> qu,int k){
int max=-999999;
for(int i=0;i<k;i++){
if(qu.front()>max){
max=qu.front();
}
qu.pop();
}
return max;
}
};
18行报错
地址溢出:堆缓冲区溢出
原因:滑动窗口右移那个for
循环多走了一轮,因为已经计算了初始窗口
多走了一轮for
循环导致j
多递增一次,访问数组下标越界
修改代码如下
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
queue<int> qu;
for(int i=0;i<k;i++){//先做一个窗口
qu.push(nums[i]);
}
vector<int> result;
result.push_back(queueMax(qu,k));
int j;//下一轮滑动窗口新加入的元素下标
j=k;
for(int i=1;i<nums.size()-k+1;i++){//滑动窗口右移
qu.pop();
qu.push(nums[j++]);
result.push_back(queueMax(qu,k));
}
return result;
}
int queueMax(queue<int> qu,int k){
int max=-999999;
for(int i=0;i<k;i++){
if(qu.front()>max){
max=qu.front();
}
qu.pop();
}
return max;
}
};
代码逻辑没有问题,但超时了
tips:printf
调试的时候每个输出做个特定标记,以免忘记后面代码有输出,导致前面测试出错
总结LeetCode数组越界(数据溢出)两种报错:
AddressSanitizer: heap-buffer-overflow on address
runtime error: reference binding to misaligned address 0xbebebebebebebebe
主要原因可能是存在数组越界
解决方法:
-
判断访问时是否下标越界
-
加入判断数组是否为空或者堆栈是否为空的语句,避免对空的数组或者堆栈进行相关操作。
看题解
这是使用单调队列的经典题目。
维护元素单调递减的队列就叫做单调队列,即单调递减或单调递增的队列。C++中没有直接支持单调队列,需要我们自己来实现一个单调队列
难点是如何求一个区间里的最大值。
- 暴力方法,遍历一遍的过程中每次从窗口中再找到最大的数值,这样很明显是O(n × k)的算法,超时
- 用一个大顶堆(优先级队列)来存放这个窗口里的k个数字,这样就可以知道最大的最大值是多少了, 但是问题是这个窗口是移动的,而大顶堆每次只能弹出最大值,我们无法移除其他数值,这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。
此时我们需要一个队列,这个队列呢,放进去窗口里的元素,然后随着窗口的移动,队列也一进一出,每次移动之后,队列告诉我们里面的最大值是什么。
class MyQueue {
public:
void pop(int value) {
}
void push(int value) {
}
int front() {
return que.front();
}
};
每次窗口移动的时候,调用que.pop(滑动窗口中移除元素的数值)
,que.push(滑动窗口添加元素的数值)
,然后que.front()
就返回我们要的最大值。
队列里的元素一定是要排序的,而且要最大值放在出队口,要不然怎么知道最大值。
但如果把窗口里的元素都放进队列里,窗口移动的时候,队列需要弹出元素。
那么问题来了,已经排序之后的队列怎么能把窗口要移除的元素(这个元素可不一定是最大值)弹出。
其实队列没有必要维护窗口里的所有元素,只需要维护有可能成为窗口里最大值的元素就可以了,同时保证队列里的元素数值是由大到小的。
不要以为实现的单调队列就是 对窗口里面的数进行排序,如果排序的话,那和优先级队列又有什么区别了呢。
看一下单调队列如何维护队列里的元素。
对于窗口里的元素{2, 3, 5, 1 ,4},单调队列里只维护{5, 4} 就够了,保持单调队列里单调递减,此时队列出口元素就是窗口里最大元素。
那么单调队列里维护着{5, 4} 怎么配合窗口进行滑动呢?
设计单调队列的时候,pop,和push操作要保持如下规则:
- pop(value):如果窗口移除的元素value等于单调队列的出口元素,那么队列弹出元素,否则不用任何操作
- push(value):如果push的元素value大于入口元素的数值,那么就将队列入口的元素弹出,直到push元素的数值小于等于队列入口元素的数值为止
保持如上规则,每次窗口移动的时候,只要问que.front()
就可以返回当前窗口的最大值。
为了更直观的感受到单调队列的工作过程,以题目示例为例,输入: nums = [1,3,-1,-3,5,3,6,7]
, 和 k = 3
,动画如下:
用什么数据结构来实现这个单调队列呢?
使用deque最为合适,queue在没有指定容器的情况下,deque就是默认底层容器。
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();
}
};
这样我们就用deque实现了一个单调队列,接下来解决滑动窗口最大值的问题就很简单了,直接看代码吧。
C++代码如下:
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;
}
};
在队列中 push
元素的过程中,还有pop
操作呢,感觉不是纯粹的O(n)。
其实,nums
中的每个元素最多也就被 push_back
和 pop_back
各一次,没有任何多余操作,所以整体的复杂度还是 O(n)。
空间复杂度因为我们定义一个辅助队列,所以是O(k)。
注意:
题解中单调队列里的pop和push接口,仅适用于本题。单调队列不是一成不变的,而是不同场景不同写法,总之要保证队列里单调递减或递增的原则,所以叫做单调队列。
对于什么是单调队列,优先队列,这里推荐一篇博客
基本数据结构:队列、单调队列与优先队列_优先队列和单调队列-CSDN博客
前 K 个高频元素
涉及优先队列知识,还未掌握
先放上题目链接:LeetCode347. 前 K 个高频元素
题解链接:链接