力扣题目练习

计算表达式的值：

package com.example.rabitmq.sy;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class Calculator {
    static Map<Character, Integer> map = new HashMap() {{
        put('+', 1);
        put('-', 1);
        put('*', 2);
        put('/', 2);
    }};

    public static void main(String[] args) {
        String expression = "17*2*2-5+1-5+3-4";
        int x = ds(expression);
        System.out.println(x);
    }

    private static int ds(String expression) {
        int length = expression.length();
        char c = ' ';
        int index = 0;
        String keepString = "";
        int res = 0;
        Stack<Integer> nums = new Stack<>();
        Stack<Character> ops = new Stack<>();
        while (true) {
            c = expression.substring(index, index + 1).charAt(0);
            if (isOrder(c)) {
                if (!ops.isEmpty()) {
                        if (order(c) > order(ops.peek())) {
                            ops.push(c);
                        } else {
                            Integer num1 = nums.pop();
                            Integer num2 = nums.pop();
                            Character pop = ops.pop();
                            res = cal(num1, num2, pop);
                            nums.push(res);
                            ops.push(c);
                        }


                }else{
                    ops.push(c);
                }
            } else {
                keepString += c;
                if (expression.length() - 1 == index) {
                    nums.push(Integer.parseInt(keepString));
                } else {
                    if (isOrder(expression.substring(index + 1, index + 2).charAt(0))) {
                        nums.push(Integer.parseInt(keepString));
                        keepString = "";
                    }
                }
            }
            index++;
            if (index >= expression.length()) {
                break;
            }

        }
        while (!ops.isEmpty()) {
            Integer num1 = nums.pop();
            Integer num2 = nums.pop();
            Character pop = ops.pop();
            res = cal(num1, num2, pop);
            nums.push(res);
        }
        return nums.pop();
    }

    private static int cal(Integer num1, Integer num2, Character ops) {
        switch (ops) {
            case '+':
                return num1 + num2;
            case '-':
                return num2 - num1;
            case '*':
                return num1 * num2;
            case '/':
                return num2 / num1;
            default:
        }
        return 0;
    }

    private static int order(char c) {
        return map.get(c);
    }

    private static boolean isOrder(char c) {
        String s = String.valueOf(c);
        return "*".equals(s) || "/".equals(s) || "+".equals(s) || "-".equals(s);
    }

}

后缀表达式：

package com.example.rabitmq.sy.s;

import java.util.*;

public class PolandNotation {
    public static void main(String[] args) {
        String expression = "1+((22+3)*4)-5";
        List<String> zh = zh(expression);
        System.out.println("中缀表达式::"+zh);
        List<String> hz = hz(zh);
        System.out.println(hz+"后缀");
        int result=ca(hz);
        System.out.println(result);
    }

    private static int ca(List<String> hz) {
        Stack<Integer> stack=new Stack<>();
        for (String s : hz) {
            if(isOps(s)){
                stack.push(Integer.parseInt(s));
            }else{
                Integer num1=stack.pop();
                Integer num2=stack.pop();
                switch (s) {
                    case "+":
                        stack.push(num1+num2);
                        break;
                    case "-":
                        stack.push(num2-num1);
                        break;
                    case "/":
                        stack.push(num2/num1);
                        break;
                    case "*":
                        stack.push(num1*num2);
                        break;
                    default:
                        break;
                }
            }
        }
        return stack.pop();
    }

    private static boolean isOps(String s1) {
        return !("+".equals(s1) || "-".equals(s1) || "/".equals(s1) || "*".equals(s1));
    }

    //定义优先级
    static Map<String, Integer> map = new HashMap() {{
        put("+", 1);
        put("-", 1);
        put("*", 2);
        put("/", 2);
        put("(", 0);
        put(")", 0);
    }};
    private static List<String> hz(List<String> infixExpressionList) {
        Stack<String> stack=new Stack<>();
        List<String> res=new ArrayList<>();
        for (String s : infixExpressionList) {
            if (s.matches("\\d+")){
                res.add(s);
            }else if (s.equals("(")){
                stack.push(s);
            }else if (s.equals(")")){
                while (!stack.peek().equals("(")){
                    res.add(stack.pop());
                }
                stack.pop(); //吐掉(
            }else{
                //比较符号的优先级 小吐了往res里面加
                while (stack.size()!=0 && order(s)<=order(stack.peek())){
                    res.add(stack.pop());
                }
                stack.push(s);
            }
        }
        while (!stack.isEmpty()){
            res.add(stack.pop());
        }
        return res;
    }

    private static int order(String s) {
        return map.get(s);
    }

    private static List<String> zh(String expression) {
        int i=0;
        char c=' ';
        String str="";
        List<String> ls=new ArrayList<>();
        while (i<expression.length()){
            if ((c=expression.charAt(i))<47 || (c=expression.charAt(i))>57) {
                ls.add(c+"");
                i++;
            }else{
                str=""; //置空的操作
                while (i<expression.length() && ((c=expression.charAt(i))>=48 && (c=expression.charAt(i))<=57)){
                    str+=c;
                    i++;
                }
                ls.add(str);
            }
        }
        return ls;
    }
}