四则运算

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        System.out.println(calculate(str));
    }
    public static int calculate(String str) {

        // 处理特殊括号,注意替换后的值，不要写错了。且replace后要重新赋值给str
        str = str.replaceAll("\\[", "(").replaceAll("\\{", "(").replaceAll("]",
                ")").replaceAll("}", ")").replaceAll(" ", "");

        //初始化两个栈，分别存放运算术和运算符
        Stack<Integer> nums = new Stack<>();
        Stack<Character> opts = new Stack<>();
        char[] cs = str.toCharArray();
        int n = cs.length;
        boolean flagOpts = false;
        boolean isNegativeNumber = false;
        for (int i = 0; i < n; i++) {
            char c = cs[i];
            //判断负数、左括号、右括号、普通运算数、+-*/
            if (Character.isDigit(c)) {
                int  v = c - '0';
                int j = i + 1;
                while (j < n && Character.isDigit(cs[j])) {
                    v = v * 10 + cs[j++] - '0';
                }
                i = j - 1;
                if (isNegativeNumber) {
                    v = -v;
                    isNegativeNumber = false;
                }
                nums.add(v);
                flagOpts = false ;
            } else {
                if (flagOpts && c == '-') {
                    isNegativeNumber = true;
                    continue;
                }
                if (c == '(') {
                    opts.add(c);
                } else if (c == ')') {
                    while (opts.peek() != '(') {
                        cal(nums, opts);
                    }
                    opts.pop();
                    continue;
                } else {
                    while (!opts.isEmpty() && getPrecedence(c) <= getPrecedence(opts.peek())) {
                        cal(nums, opts);
                    }
                    opts.add(c);
                }
                flagOpts = true ;
            }
        }
        while (!opts.isEmpty()) {
            cal(nums, opts);
        }
        return nums.peek();
    }
    // 获取运算符的优先级
    public static int getPrecedence(char operator) {
        switch (operator) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
        }
        return 0;
    }

    public static void cal(Stack<Integer> nums, Stack<Character> opts) {
        if (nums.isEmpty() || nums.size() < 2) {
            return;
        }
        if (opts.isEmpty()) {
            return;
        }
        int b = nums.pop(), a = nums.pop();
        char op = opts.pop();
        int ans = 0;
        switch (op) {
            case '+' :
                ans = a + b;
                break;
            case '-':
                ans = a - b;
                break;
            case '*':
                ans = a * b;
                break;
            case '/':
                ans = a / b;
                break;
            default:
                break;
        }
        nums.add(ans);
    }

}

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static String[] types = new String[]{"\\+","-","\\*", "/"};
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        // 统一括号
        s = s.replaceAll("\\[", "(").replaceAll("\\]", ")")
             .replaceAll("\\{", "(").replaceAll("\\}", ")");
        // 开头减号一定是负号，先替换，防止用减号分割出现错误，最后计算时换回负号
        s = s.replaceAll("\\(-", "(="); 
        if (s.startsWith("-")) s = "="+s.substring(1);

        while (s.contains(")")) {
            //先计算括号内数据
            int r = s.indexOf(")"); // 第一个右括号
            //截止到第一个有括号的最后一个左括号为单一公式
            int l = s.substring(0,r).lastIndexOf("("); 
            // 计算不包含括号的单一公式
            int ans = calc(s.substring(l+1, r), 0);
            // 结果写回算式，注意结果为负值的负号处理
            s = s.substring(0, l) + (ans+"").replace("-", "=") + s.substring(r+1);
        }
        System.out.print(calc(s, 0));
    }

    public static int calc(String s, int t) {
        // 按加减乘除四次分割，可以确保先乘除后加减
        int ans = 0; //加法的初始值
        if (t == 2) ans = 1; //乘法的初始值
        // 防止前面括号带入
        s = s.replace("(", "").replace(")", "");
        // 按顺序分割
        String[] plus = s.split(types[t]);
        for (int i=0; i<plus.length; i++) {
            String p = plus[i];
            if (t == 0)
                ans += calc(p, t+1);
            else if (t == 1) {
                int curr = calc(p, t+1);
                // 减法需要先得到第一个，后面逐次减法
                if (i == 0) ans = curr;
                else ans -= curr;
            }
            else if (t == 2) {
                ans *= calc(p, t+1);
            }
            else if (t == 3) {
                int curr = Integer.parseInt(p.replaceAll("=", "-"));
                // 除法需要先得到第一个，后面逐次除法
                if (i == 0) ans = curr;
                else ans /= curr;
            }
        }
        return ans;
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    // 存放算数优先级
    public static HashMap<Character, Integer> map = new
    HashMap<Character, Integer>() { //这里泛型必须写
        // 声明优先级
        {
            put('-', 1);
            put('+', 1);
            put('*', 2);
            put('/', 2);
        }
    };

    public static boolean isNumber(char c) {
        return Character.isDigit(c);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        System.out.println(calculate(str));
    }

    public static int calculate(String str) {

        // 处理特殊括号,注意替换后的值，不要写错了。且replace后要重新赋值给str
        str = str.replaceAll("\\[", "(").replaceAll("\\{", "(").replaceAll("\\]",
                ")").replaceAll("\\}", ")").replaceAll(" ", "");

        // 处理负数
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == '-') {
                if (i == 0 || str.charAt(i - 1) == '+' || str.charAt(i - 1) == '-' ||
                        str.charAt(i - 1) == '*' || str.charAt(i - 1) == '/' ||
                        str.charAt(i - 1) == '(')
                    str = str.substring(0, i) + "#" + str.substring(i + 1);

            }
        }

        //初始化两个栈，分别存放运算术和运算符
        Stack<Integer> nums = new Stack<>();
        Stack<Character> opts = new Stack<>();
        char[] cs = str.toCharArray();
        int n = cs.length;
        for (int i = 0; i < n; i++) {
            char c = cs[i];

            //判断负数、左括号、右括号、普通运算数、+-*/
            if (c == '#') {
                int j = i + 1, v =
                            0; // 运算符往后一位，所以是i+1，正数会直接是j=i
                while (j < n && isNumber(cs[j])) {
                    v = v * 10 + cs[j++] - '0';
                }
                nums.add(-v);
                i = j - 1; //多位数处理
            } else if (c == '(') {
                opts.add(c);
            } else if (c == ')') {
                // 计算括号内的数据，直到栈顶为（为止
                while (opts.peek() != '(') {
                    cal(nums, opts);
                }
                opts.pop(); //左括号出栈
            } else {

                // 正数
                if (isNumber(c)) {
                    int j = i, v = 0;
                    while (j < n && isNumber(cs[j])) {
                        v = v * 10 + cs[j++] - '0';
                    }
                    nums.add(v);
                    i = j - 1;
                } else {
                    while(!opts.isEmpty() && opts.peek() != '('){
                        char prev = opts.peek();
                        if(map.get(prev) >= map.get(c)){
                            cal(nums,opts);
                        }else{
                            break;
                        }
                    }
                    opts.add(c);
                    
            }
        
        }
        }

        while (!opts.isEmpty()) {
            cal(nums, opts);
        }

        return nums.peek();

    }

    public static void cal(Stack<Integer> nums, Stack<Character> opts) {
        if (nums.isEmpty() || nums.size() < 2) {
            return;
        }

        if (opts.isEmpty()) {
            return;
        }

        int b = nums.pop(), a = nums.pop();
        char op = opts.pop();
        int ans = 0;
        switch (op) {
            case '+' :
                ans = a + b;
                break;
            case '-':
                ans = a - b;
                break;
            case '*':
                ans = a * b;
                break;
            case '/':
                ans = a / b;
                break;
            default:
                break;
        }
        nums.add(ans);
    }

}

import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.text.DecimalFormat;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    private static Map<Character, Integer> ***bsp;= new HashMap<>();

    public static void main(String[] args) {
        por.put('+', 0);
        por.put('-', 0);
        por.put('*', 1);
        por.put('/', 1);
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String str = sc.nextLine().trim().replace("{", "(").replace("}", ")")
                    .replace("[", "(").replace("]", ")");
            if (str.startsWith("-")) {
                str = "0" + str;
            }
            StringBuilder sb0 = new StringBuilder();
            for (int i = 0; i < str.length(); i++) {
                if (i > 0 && str.charAt(i) == '-' && str.charAt(i - 1) == '(') {
                    sb0.append("0");
                }
                sb0.append(str.charAt(i));
            }
            str = sb0.toString();
//            System.out.println(str);
            Stack<Character> stack = new Stack<>();
            List<String> list = new ArrayList<>();
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                switch (c) {
                    case '+':
                    case '-':
                    case '*':
                    case '/':
                        while (stack.size() > 0 && stack.peek() != '(' && por.get(c) <= por.get(stack.peek())) {
                            list.add(stack.pop() + "");
                        }
                        stack.push(c);
                        break;
                    case '(':
                        stack.push(c);
                        break;
                    case ')':
                        while (stack.size() > 0) {
                            Character pop = stack.pop();
                            if (pop != '(') {
                                list.add(pop + "");
                            } else {
                                break;
                            }
                        }
                        break;
                    default:
                        String num = c + "";
                        while (i < str.length() - 1 && str.charAt(i + 1) >= '0' && str.charAt(i + 1) <= '9') {
                            num += str.charAt(i + 1);
                            i++;
                        }
                        list.add(num);
                }
            }
            while (stack.size() > 0) {
                list.add(stack.pop() + "");
            }
            double res = calc(list.toArray(new String[]{}));
            DecimalFormat df = new DecimalFormat("0.################");
            System.out.println(df.format(res));
        }
    }

    private static double calc(String[] pattern) {
        for (int i = pattern.length - 1; i >= 0; i--) {
            String s = pattern[i];
            if (s.length() == 1 && por.containsKey(s.charAt(0)) && i > 1 && isNum(pattern[i - 1]) && isNum(pattern[i - 2])) {
                double v1 = Double.parseDouble(pattern[i - 1]);
                double v2 = Double.parseDouble(pattern[i - 2]);
                double res = getRes(s, v1, v2);
                pattern[i] = "null";
                pattern[i - 2] = res + "";
                pattern[i - 1] = "null";
            }
        }
        String[] arr = Arrays.stream(pattern).filter(s -> !s.equals("null")).collect(Collectors.toList()).toArray(new String[]{});
        if(arr.length==1){
            return Double.parseDouble(arr[0]);
        }
        if (arr.length == 3) {
            double r = getRes(arr[arr.length - 1], Double.parseDouble(arr[1]), Double.parseDouble(arr[0]));
            return r;
        }
        return calc(arr);
    }

    private static double getRes(String op, double v1, double v2) {
        double res;
        switch (op) {
            case "+":
                res = v2 + v1;
                break;
            case "-":
                res = v2 - v1;
                break;
            case "*":
                res = v2 * v1;
                break;
            default:
                res = v2 / v1;
                break;
        }
        return res;
    }

    private static boolean isNum(String value) {
        try {
            Double.parseDouble(value);
        } catch (NumberFormatException e) {
            return false;
        }
        return true;
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

/**
 * @className: _4_9
 * @author: Lian
 * @date: 2023-10-03 16:51
 */
public class _5_0 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Stack<Character> operator = new Stack<>();
        ArrayList<String> list = new ArrayList<>();
        Map<Character, Integer> hashMap = new HashMap<>();
        Stack<Double> stack = new Stack<>();
        hashMap.put('(', 0);
        hashMap.put('-', 1);
        hashMap.put('+', 1);
        hashMap.put('*', 2);
        hashMap.put('/', 2);
        StringBuilder str = new StringBuilder(br.readLine().replace('{', '(').replace('}', ')').replace('[', '(').replace(']', ')'));
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == '-')
                count++;
        }
        while (true) {
            for (int i = 0; i < str.length(); i++) {
                if (str.charAt(i) == '-') {
                    if (i == 0 ||str.charAt(i)=='(') {
                        str.insert(i + 2, ")");
                        str.insert(i, "(0");
                        break;
                    }
                }
            }
            break;
        }

        char[] chars = str.toString().toCharArray();

        for (int i = 0; i < chars.length; i++) {
            if (Character.isDigit(chars[i])) {
                int j = 0;
                while (i+j<chars.length&&Character.isDigit(chars[i + j])) {
                    j++;
                }
                list.add(String.copyValueOf(chars, i, j));
                i=i+j-1;
                continue;
            }
            if (chars[i] == '(') {
                operator.push(chars[i]);
                continue;
            }
            if (chars[i] == ')') {
                while (operator.peek() != '(') {
                    char c = operator.pop();
                    list.add(String.valueOf(c));
                }
                operator.pop();
                continue;
            }
            if (operator.isEmpty()) {
                operator.push(chars[i]);
                continue;
            }
            while (!operator.isEmpty() && hashMap.get(chars[i]) <= hashMap.get(operator.peek())) {
                char c = operator.pop();
                list.add(String.valueOf(c));
            }
            operator.push(chars[i]);
        }
        while (!operator.isEmpty()) {
            list.add(String.valueOf(operator.pop()));
        }

        for (int i = 0; i < list.size(); i++) {
            if (Character.isDigit(list.get(i).charAt(0))) {
                stack.push(Double.valueOf(list.get(i)));
                continue;
            }
            double a = stack.pop();
            double b = stack.pop();
            if (list.get(i).equals("+")) {
                stack.push(a + b);
                continue;
            }
            if (list.get(i).equals("*")) {
                stack.push(a * b);
                continue;
            }
            if (list.get(i).equals("-")) {
                stack.push(b - a);
                continue;
            }
            if (list.get(i).equals("/")) {
                stack.push(b / a);
            }
        }

        System.out.printf("%.0f%n", stack.peek());
    }
}

public class Test01 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { 
            String str = in.nextLine();
            System.out.println(solution(str));
        }
    }
    public static int solution(String str){
        Stack<Integer> numStack = new Stack<>();
        Stack<Character> pStack = new Stack<>();
        for (int i = 0; i < str.length(); i++) {
            char a = str.charAt(i);
            //1、如果是括号
            if(a=='('||a=='['||a=='{'){ 
                pStack.push(a);
                int end = i;
                //找到括号的结尾
                for (int j = i+1; j < str.length(); j++) {
                    char k = str.charAt(j);
                    if(k=='('||k=='['||k=='{'){
                        pStack.push(k);
                    }else if(k==')'||k==']'||k=='}'){
                        pStack.pop();
                        if(pStack.isEmpty()||(pStack.peek()!='('&& pStack.peek()!='{'&& pStack.peek()!='[')){
                            end = j;
                            break;
                        }
                    }
                }
                //递归计算括号中的结果push到数字栈中。
                numStack.push(solution(str.substring(i+1,end)));
                //更新i的值。
                i=end;
            }else if((i==0&&a=='-')||Character.isDigit(a)){ //2、找到的是数字，需要考虑负数开头。
                String num = a+"";
                i++;
                while(i<str.length()&&Character.isDigit(str.charAt(i))){
                    num+=str.charAt(i);
                    i++;
                }
                numStack.push(Integer.parseInt(num));
                i--;
            }else{ //3、找到的是符号
                if(!pStack.isEmpty()){
                    //如果找到的符号运算级小于等于栈中的符号，则先计算栈中的，如果大于栈中运算符，直接push。
                    if(a=='+'||a=='-'){
                        //遇到+、-需要将栈中的全部都计算了。
                        while(!pStack.isEmpty()){
                            numStack.push(operation(numStack.pop(),numStack.pop(),pStack.pop()));
                        }
                    }else if((a=='*'|| a=='/')&&(pStack.peek()=='*'||pStack.peek()=='/')){
                        numStack.push(operation(numStack.pop(),numStack.pop(),pStack.pop()));
                    }
                }
                //将运算符压入符号栈。
                pStack.push(a);
            }
        }
        //计算剩余元素的结果。
        while(!pStack.isEmpty()){
            numStack.push(operation(numStack.pop(),numStack.pop(),pStack.pop()));
        }
        return numStack.pop();
    }
    public static int operation(int a , int b , Character p){
        if(p=='+'){
            return b+a;
        }else if(p=='-'){
            return b-a;
        }else if(p=='*'){
            return b*a;
        }else{
            return b/a;
        }
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String express = in.next();
        express = express.replace("{", "(");
        express = express.replace("[", "(");
        express = express.replace("}", ")");
        express = express.replace("]", ")");

        System.out.print(comput(dealParent(express)));

    }
    // 处理括号
    public static String dealParent(String str) {
        ArrayList<Integer> parent = new ArrayList<>();
        char[] carr = str.toCharArray();
        String temp = str;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < carr.length; i++) {
            if (carr[i] == '(') {
                parent.add(i);
            }
            if (carr[i] == ')') {
                int start = parent.get(parent.size() - 1);
                String com = temp.substring(start + 1, i);
                String res = comput(com);
                sb.append(temp.substring(0, start));
                // 添加空格补齐位数
                int differ = i - start + 1 - res.length();
                for (int j = 0; j < differ; j++) {
                    sb.append(" ");
                }
                sb.append(res);
                if (i != carr.length - 1) {
                    sb.append(temp.substring(i + 1, temp.length()));
                }
                temp = sb.toString();
                sb.setLength(0);
                parent.remove(parent.size() - 1);
            }
        }
        return temp;
    }
    // 将字符串公式拆分成字符串数组
    public static ArrayList<String> toStrArr(String str) {
        str = str.replace(" ", "");
        ArrayList<String> exArr = new ArrayList<>();
        char[] carr = str.toCharArray();
        int start = 0;
        for (int i = 0; i < carr.length; i++) {
            if (i == 0 && carr[i] == '-') {
                continue;
            }
            if (carr[i] == '-' && (carr[i - 1] == '+' || carr[i - 1] == '*' ||
                                   carr[i - 1] == '/' || carr[i - 1] == '-')) {
                continue;
            }
            if (carr[i] == '+' || carr[i] == '-' || carr[i] == '*' || carr[i] == '/') {
                exArr.add(str.substring(start, i));
                exArr.add(str.substring(i, i + 1));
                start = i + 1;
            }
            if (i == carr.length - 1) {
                exArr.add(str.substring(start, carr.length));
            }
        }
        return exArr;
    }
    // 不带括号的计算
    public static String comput(String str) {
        ArrayList<String> arr = toStrArr(str);
        for (int i = 0; i < arr.size(); i++) {
            if (arr.get(i).equals("*") || arr.get(i).equals("/")) {
                int a = Integer.parseInt(arr.get(i - 1));
                int b = Integer.parseInt(arr.get(i + 1));
                int res;
                if (arr.get(i).equals("*")) {
                    res = a * b;
                } else {
                    res = a / b;
                }
                arr.set(i + 1, String.valueOf(res));
                arr.set(i, " ");
                arr.set(i - 1, " ");
                i++;
            }
        }
        while (arr.contains(" ")) {
            arr.remove(" ");
        }
        for (int i = 0; i < arr.size(); i++) {
            if (arr.get(i).equals("+") || arr.get(i).equals("-")) {
                int a = Integer.parseInt(arr.get(i - 1));
                int b = Integer.parseInt(arr.get(i + 1));
                int res;
                if (arr.get(i).equals("+")) {
                    res = a + b;
                } else {
                    res = a - b;
                }
                arr.set(i + 1, String.valueOf(res));
                arr.set(i, " ");
                arr.set(i - 1, " ");
                i++;
            }
        }
        while (arr.contains(" ")) {
            arr.remove(" ");
        }
        return arr.get(0);
    }

}

import java.util.*;

// 大无语，怎么有这种这么繁琐的题啊 ！！！！
public class Main {
    public static int index = 0;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.next();
        System.out.println(getExpression(s));
    }
    public static int getExpression(String s) {
        ArrayList<Integer> numArray = new ArrayList<>();
        ArrayList<Character> signArray = new ArrayList<>();
        HashMap<Character, Character> hp = new HashMap<>();
        hp.put('[', ']');
        hp.put('(', ')');
        hp.put('{', '}');

        int i = 0;
        int count = 0;
        StringBuilder strBuilder;
        while (i < s.length()) {
            if (i >= s.length()) break;
            char ch = s.charAt(i);
            if (ch == '(' || ch == '[' || ch == '{') {
                i++;
                count = 0;
                strBuilder = new StringBuilder();
                while (i < s.length() && (s.charAt(i) != hp.get(ch) || count != 0)) {
                    if (s.charAt(i) == ch) count++;
                    if (s.charAt(i) == hp.get(ch)) count--;
                    strBuilder.append(s.charAt(i));
                    i++;
                }
                i++;
                numArray.add(getExpression(strBuilder.toString()));
            }else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
                signArray.add(ch);
                i++;
            } else {
                int num = 0;
                while (i < s.length() && s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                    num = num * 10 + s.charAt(i) - '0';
                    i++;
                }
                numArray.add(num);
            }
        }
        
        Stack<Character> signStack = new Stack<>();
        Stack<Integer> numStack = new Stack<>();
        int indexArrayNum = 0, indexArraySign = 0;
        if (numArray.size() == signArray.size()) {
            numArray.set(0,-numArray.get(0));
            indexArraySign++;
        }
        numStack.push(numArray.get(indexArrayNum++));
        while (indexArraySign < signArray.size()) {
            char ch = signArray.get(indexArraySign++);
            if (ch == '+' || ch == '-') {
                signStack.push(ch);
                numStack.push(numArray.get(indexArrayNum++));
            }
            else if (ch == '*') {
                int a = numStack.pop();
                int b = numArray.get(indexArrayNum++);
                numStack.push(a * b);
            }else {
                int a = numStack.pop();
                int b = numArray.get(indexArrayNum++);
                numStack.push(a / b);
            }
        }
        Stack<Character> signStack02 = new Stack<>();
        Stack<Integer> numStack02 = new Stack<>();
        while (!signStack.isEmpty()) {
            signStack02.push(signStack.pop());
        }
        while (!numStack.isEmpty()) {
            numStack02.push(numStack.pop());
        }
        while (!signStack02.isEmpty()) {
            int a = numStack02.pop();
            int b = numStack02.pop();
            char ch = signStack02.pop();
            if (ch == '+')
                numStack02.push(a + b);
            else
                numStack02.push(a - b);
        }

        return numStack02.pop();
    }
}

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
import java.util.Stack;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        //中括号、大括号全部转为小括号，方便处理
        str = str.replace('[', '(');
        str = str.replace('{', '(');
        str = str.replace(']', ')');
        str = str.replace('}', ')');
        //1.将String类型的中缀表达式转成List<String>类型的中缀表达式
        List<String> infixList = infixStringToList(str);
        //2.将List<String>类型的中缀表达式转成List<String>类型的后缀表达式
        List<String> suffixList = infixToSuffix(infixList);
        //3.将List<String>类型的后缀表达式进行计算
        int res = calculateSuffixNotation(suffixList);
        System.out.println(res);
    }
    //1.将String类型的中缀表达式转成List<String>类型
    public static List<String> infixStringToList(String str) {
        List<String> list = new ArrayList<>();
        int i = 0;
        while (i < str.length()) {
            if (str.charAt(i) == '+' || str.charAt(i) == '*' || str.charAt(i) == '/' || str.charAt(i) == '(' || str.charAt(i) == ')') {
                list.add(String.valueOf(str.charAt(i)));
                i++;
            } else if (str.charAt(i) == '-') {//考虑负数
                if ((str.charAt(i) == '-' && str.charAt(i-1) == '(' && str.charAt(i+1)>= 48 && str.charAt(i+1)<= 57) || (str.charAt(i) == '-' && i == 0 && str.charAt(i+1)>= 48 && str.charAt(i+1)<= 57)) {
                    list.add(String.valueOf(str.charAt(i))+String.valueOf(str.charAt(i+1)));
                    i = i + 2;
                } else {
                    list.add(String.valueOf(str.charAt(i)));
                    i++;
                }
            } else {
                StringBuilder sb = new StringBuilder();
                //考虑多位数
                while (i < str.length() && str.charAt(i) >= 48 && str.charAt(i) <= 57) {
                    sb.append(str.charAt(i));
                    i++;
                }
                list.add(sb.toString());
            }
        }
        return list;
    }
    //2.将List<String>类型的中缀表达式转成List<String>类型的后缀表达式
    public static List<String> infixToSuffix(List<String> infixList) {
        Stack<String> operationStack = new Stack<>();
        List<String> tempResList = new ArrayList<>();
        for (String s : infixList) {
            if (s.matches("\\d+")) {
                tempResList.add(s);
            } else if (s.matches("-\\d+")) {
                tempResList.add(s);
            } else if ("(".equals(s)) {
                operationStack.push(s);
            } else if (")".equals(s)) {
                while (!operationStack.peek().equals("(")) {
                    tempResList.add(operationStack.pop());
                }
                operationStack.pop();//去掉"("
            } else {
                //如果s的运算优先级小于等于operationStack栈顶元素的优先级
                //将operationStack栈顶元素弹出并加入tempResList中
                //直到s可以入operationStack栈
                while (operationStack.size() != 0 && operationPriority(s) <= operationPriority(operationStack.peek())) {
                    tempResList.add(operationStack.pop());
                }
                operationStack.push(s);
            }
        }
        while (operationStack.size() != 0) {
            tempResList.add(operationStack.pop());
        }
        return tempResList;
    }
    //3.将List<String>类型的后缀表达式进行计算
    //思想：遇到数字入栈,遇到操作符则将栈顶元素和栈顶元素的下一个元素进行操作符对应的运算后入栈
    //     其中被减数和被除数是栈顶元素的下一个元素
    public static int calculateSuffixNotation(List<String> suffixList) {
        Stack<Integer> stack = new Stack<>();
        for (String s : suffixList) {
            if ("+".equals(s)) {
                stack.push(stack.pop()+stack.pop());
            } else if ("-".equals(s)) {
                stack.push(-stack.pop()+stack.pop());
            } else if ("*".equals(s)) {
                stack.push(stack.pop()*stack.pop());
            } else if ("/".equals(s)) {
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2 / temp1);
            } else {
                stack.push(Integer.parseInt(s));
            }
        }
        //经过以上运算最终栈中只剩下一个元素
        return stack.pop();
    }
    public static int operationPriority(String operation) {
        if ("+".equals(operation) || "-".equals(operation)) {
            return 0;
        } else if ("*".equals(operation) || "/".equals(operation)) {
            return 1;
        } else {
            return -1;
        }
    }
}