【Leetcode】227. Basic Calculator II

最新推荐文章于 2022-08-29 13:11:23 发布

只只只只只只

最新推荐文章于 2022-08-29 13:11:23 发布

阅读量244

点赞数

分类专栏： LEETCODE 文章标签： Leetcode java

本文链接：https://blog.csdn.net/zhizhi_zhizhi_zhizhi/article/details/56679085

版权

LEETCODE 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

227. Basic Calculator II

Implement a basic calculator to evaluate a simple expression string.

The expression string contains only non-negative integers, +, -, *, / operators and empty spaces . The integer division should truncate toward zero.

You may assume that the given expression is always valid.

Some examples:

"3+2*2" = 7
" 3/2 " = 1
" 3+5 / 2 " = 5

Note: Do not use the eval built-in library function.

题目分析：

输入一个运算的字符串，需要输出字符串的运行结果。题目假定输入的运算字符串都是有意义的。

思路简介：

思路一：只从字符串处理的角度出发的话，我考虑使用Stack来处理这题。

首先，将字符串从后向前存入栈中，这样栈弹出的时候就与字符串的真实顺序一致。每次存要么存数，要么存操作符，这样之后弹出的元素就是一个完整的部分。

初始化sum=0;每次Stack弹出三个元素，其中一定包含两个数字和一个操作符号(num1,oper,num2)。

如果符号是"+"那么将第一个数字加到sum中,将num2压回栈中（因为不知道num2之后的操作符是否比oper优先级高）

如果符号是"-"那么将num2取负，并压回栈中。

如果符号是" * “ ” / "，将num1和num2的运算结果压回栈中。

之后代码我实现了两个方式，一个是将操作符和数字都存在一个Stack<String>中。二是分开存储NumStack<Integer>/OperStack<Character>，但是二者的速度差不多，失败~~

复杂度：

时间复杂度O(N)

空间复杂度O(N)

代码：

public class Solution {
public int calculate(String s) {
//方法一，用一个栈来做这件事

/*
Stack<String> aStack = new Stack<String>();
getStack(aStack,s);
int sum=0;
while(true){
String num1=aStack.pop();
if(aStack.isEmpty()==true){
sum += Integer.parseInt(num1);
break;
}
String oper=aStack.pop();
String num2=aStack.pop();
if(oper.charAt(0)=='+'||oper.charAt(0)=='-'){
sum +=Integer.parseInt(num1);
if(oper.charAt(0)=='-'){
num2 = "-"+num2;
}
aStack.push(num2);
}else{
if(oper.charAt(0)=='*'){
aStack.push(Integer.parseInt(num1)*Integer.parseInt(num2)+"");
}else{
aStack.push(Integer.parseInt(num1)/Integer.parseInt(num2)+"");
}
}

}
return sum;
*/

//方法二：分开处理这件事
Stack<Integer> aNumStack= new Stack<Integer>();
Stack<Character> aOperStack= new Stack<Character>();
int sum = 0;
getStack(aOperStack,aNumStack,s);
if(aOperStack.isEmpty()==true){
return aNumStack.pop();
//break;
}
while(true){
int num1 = aNumStack.pop();

int num2 = aNumStack.pop();
char oper = aOperStack.pop();

if(oper=='+'||oper=='-'){
sum += num1;
if(oper == '-'){
num2 = -1*num2;
}
aNumStack.push(num2);
}else{
if(oper == '*'){
aNumStack.push(num1*num2);
}else{
aNumStack.push(num1/num2);
}
}
if(aOperStack.isEmpty()==true){
sum+= aNumStack.pop();
break;
}
}
return sum;
}
//用一个栈来解决所有问题，简单但是速度慢
public void getStack(Stack<String> aStack,String s){
String aSec="";
for(int i=s.length()-1;i>=0;i--){
//String aSec="";
if(s.charAt(i)!=' '){
if(s.charAt(i)<='9'&&s.charAt(i)>='0'){
aSec = s.charAt(i)+aSec;
}else{
aStack.push(aSec);
aStack.push(s.charAt(i)+"");
aSec="";
}
}
}
aStack.push(aSec);
}
//一个栈存储数字，一个栈存储操作符
public void getStack(Stack<Character> aOperStack,Stack<Integer> aNumStack,String s){
String aSec="";
for(int i=s.length()-1;i>=0;i--){
if(s.charAt(i)!=' '){
if(s.charAt(i)<='9' && s.charAt(i)>= '0'){
aSec = s.charAt(i)+aSec;
}else{
aNumStack.push(Integer.parseInt(aSec));
aOperStack.push(s.charAt(i));
aSec="";
}
}
}
aNumStack.push(Integer.parseInt(aSec));
}

}