算法刷题笔记-stack-四则运算

题目描述：

给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。

示例 1:

输入: "2-1-1"
输出: [0, 2]
解释:
((2-1)-1) = 0
(2-(1-1)) = 2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/different-ways-to-add-parentheses

解题思路：

　　1、每次仅运算乘除，将运算结果入栈，

　　　　a、保留前一个运算符

　　　　b、如果前一个运算符是乘除，弹出一个数字，与当前运算，结果回送。

　　　　c、如果是减号，将当前数字取负，送进堆栈；正号，直接入栈

　　2、扫描结束后，对栈中所有元素求和。结束

java语言实现：

 class Solution {
     public static int calculate(String s) {
         int res = 0;
         int num = 0;
         char sign = '+';
         Stack<Integer> stack = new Stack<>();
         char[] sarr = s.toCharArray();
         for (int i = 0; i < sarr.length; i++) {
             if (sarr[i] >= '0') {
                 num = num * 10 + sarr[i] - '0'; // 注意字符变成数字，方可参加运算，否则直接ASCII码参与运算，出错。
             }
             if ((sarr[i] < '0' && sarr[i] != ' ') || i == sarr.length - 1) {
                 if (sign == '+') {
                     stack.push(num);
                 } else if (sign == '-') {
                     stack.push(-num);
                 } else if (sign == '*' || sign == '/') {
                     int top = stack.pop();
                     stack.push(sign == '*' ? top * num : top / num);
                 }
                 sign = sarr[i];
                 num = 0;
             }
         }
         while (!stack.isEmpty()) {
             res += stack.pop();
         }
         return res;
     }

     public static int calculate2(String s) {
     　　 s=s.trim();  //清洗输入数据，并记得将洗过的数据回送给s
         java.util.Stack<Integer> stack = new java.util.Stack<>();
 //        String[] nums=s.split("[-+/*]");
         int left_number=0;
         char fuhao_before='+';  //保存前一个符号
         char fuhao;
         for (int i=0;i<s.length();i++){
             if (Character.isDigit(s.charAt(i))){
                 left_number=left_number*10+s.charAt(i)-'0';

             }if(i==s.length()-1 || ! Character.isDigit(s.charAt(i))){
                 fuhao=s.charAt(i);
                 switch (fuhao_before){
                     case '+':
                         stack.push(left_number);
                         fuhao_before=fuhao;
                         break;
                     case '-':
                         stack.push(-left_number);
                         fuhao_before=fuhao;
                         break;
                     case '*':
                         stack.push(stack.pop()*left_number);  //其实是右边的数
                         fuhao_before=fuhao;
                         break;
                     case '/':
                         stack.push(stack.pop()/left_number);
                         fuhao_before=fuhao;
                         break;
                     default:
                         break;

                 }
                 left_number=0; //归零
             }
         }

         int result=0;
         while (! stack.empty()){
             result+=stack.pop();

         }
         return result;
     }
 }