数据结构算法爬坑日记五

计算规则

概念
前缀(波兰表达式):前缀表达式的运算符位于操作数之前 如(3+4)*5-6 ==> - * + 3 4 5 6
	计算时从右向左扫描,遇到数将其压入堆栈,遇到符号从栈内弹出两个数进行计算,将结果再次入栈,扫描结
	束,栈内的值即为结果,减和除先弹出的数在前
中缀表达式:我们日常使用的形式(计算机不易识别)
后缀(逆波兰表达式):运算符位于操作数之后 如 (3+4)*5-6 ==> 3 4 + 5 * 6 -
	计算时从左到右扫描,遇到数将其压入堆栈,遇到符号从栈内弹出两个数进行计算,将结果再次入栈,扫描结
	束,栈内的值即为结果,减和除后弹出的数在前

中缀转后缀算法:
1.初始化两个栈num和oper
2.对中缀字符串依次扫描
3.遇到数字直接压入num栈
4.遇到括号
  ** 如果是"(",直接压入oper栈
  ** 如果是")",依次弹出oper栈的栈顶数据,直到遇到"(",将此括号弹出
5.遇到运算符
  ** 如果num栈空或者栈内为"("或者优先级比栈顶高,直接将其压入oper栈
  ** 若运算符比栈顶低或相等,将oper栈顶弹出并压入nun栈,再次从第5步进行判断
6.扫描完成后,将oper栈依次弹出并压入到num栈
7.num栈内元素依次弹出的逆序表达式即为此中缀表达式的后缀表达式

计算器

只考虑四则运算且不考虑小数情况

//后缀表达式 (不考虑小数)
public class Poland {
    public static void main(String[] args) {
        String str = "(3+4)*5-6";
        List<String> list = toInfixExpressionList(str);
        System.out.println(calculate(toSuffixExpression(list)));
    }

    //中缀表达式转后缀
    public static List<String> toSuffixExpression(List<String> list) {
        Stack<String> operStack = new Stack<>(); // 符号栈
        List<String> num = new ArrayList<>(); // 代替数栈
        for (String item : list) {
            //如果是多位数
            if (item.matches("\\d+")) {
                num.add(item);
            } else if ("(".equals(item)) {
                //如果是左括号
                operStack.push(item);
            } else if (")".equals(item)) {
                //如果是右括号，只要栈顶不是(就一直弹出加入数栈
                while (!"(".equals(operStack.peek())) {
                    num.add(operStack.pop());
                }
                //消除左括号
                operStack.pop();
            } else {
                //如果为运算符
                while (operStack.size() != 0 && !"(".equals(operStack.peek()) && priority(item.charAt(0)) <= priority(operStack.peek().charAt(0))) {
                    //如果其优先级不大于栈顶且符号栈不为空且栈顶不为"("
                    num.add(operStack.pop());
                }
                operStack.push(item);
            }
        }
        //将符号栈依次弹出如数栈
        while (operStack.size() != 0) {
            num.add(operStack.pop());
        }
        // 循环集合正序返回即为对应后缀表达式
        return num;
    }

    //将中缀串依次存入list集合内
    public static List<String> toInfixExpressionList(String str) {
        int index = 0; // 字符串遍历指针
        String s;// 多位数的拼接
        char c;// 存放每次遍历的值
        List<String> list = new ArrayList<>();
        while (index < str.length()) {
            //如果不是数字存入集合
            if ((c = str.charAt(index)) < '0' || (c = str.charAt(index)) > '9') {
                list.add(c + "");
                index++;
            } else {
                //如果是数字
                s = "";
                //如果下一个还是数字就拼接多位数
                while (index < str.length() && str.charAt(index) >= '0' && (c = str.charAt(index)) <= '9') {
                    s += c;
                    index++;
                }
                list.add(s);
            }
        }
        return list;
    }

    //判断符号运算符优先级
    public static int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '-' || oper == '+') {
            return 0;
        } else {
            return -1;
        }
    }

    //将后缀表达式存入集合中
    public static List<String> getStrList(String str) {
        List<String> list = new ArrayList<>();
        String[] strings = str.split(" ");
        Collections.addAll(list, strings);
        return list;
    }

    //计算
    public static int calculate(List<String> list) {
        Stack<String> stack = new Stack<>(); // 数栈
        for (String str : list) {
            //利用正则判断是否是数字
            if (str.matches("\\d+")) {
                stack.push(str);
            } else {
                int num1 = Integer.parseInt(stack.pop());//弹出第一个数
                int num2 = Integer.parseInt(stack.pop());//弹出第二个数
                int res;//运算结果
                if ("+".equals(str)) {
                    res = num1 + num2;
                } else if ("-".equals(str)) {
                    res = num2 - num1;
                } else if ("*".equals(str)) {
                    res = num1 * num2;
                } else if ("/".equals(str)) {
                    res = num2 / num1;
                } else {
                    throw new RuntimeException("符号有误");
                }
                stack.push(res + "");
            }
        }
        return Integer.parseInt(stack.pop());
    }
}