前缀、中缀、后缀表达式

前缀、中缀、后缀表达式

前缀表达式(波兰表达式)

1. 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前
2. 举例说明： (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6
   

中缀表达式

1. 中缀表达式就是常见的运算表达式，如(3+4)×5-6
2. 中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式.)

后缀表达式

1. 后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后
2. 举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –

后缀表达式的计算机求值

从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:

1. 从左至右扫描，将3和4压入堆栈；
2. 遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
3. 将5入栈；
4. 接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
5. 将6入栈；
6. 最后是-运算符，计算出35-6的值，即29，由此得出最终结果

代码实现（后缀表达式的计算）

/***
     * @description: 将一个逆波兰表达式的数据和运算符依次放入ArrayList中
     * @param: suffixExpression
     * @return: java.util.List<java.lang.String>
     * @author ZhangJiaHao
     * @date: 2021/12/3 16:49
     */
    public static List<String> getListString(String suffixExpression){
        // 将suffixExpression进行分割
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
        for (String s : split) {
            list.add(s);
        }
        return list;
    }

 /***
     * @description: 将传进来的list进行运算，后缀表达式的运算
     * @param: ls
     * @return: int
     * @author ZhangJiaHao
     * @date: 2021/12/3 16:54
     */
    public static int calculate(List<String> ls){
        // 创建栈
        Stack stack = new Stack();
        int num1;
        int num2;
        int result;
        for (String item : ls) {
            if (item.matches("\\d+")){ // 这里使用正则表达式进行判断是不是为数字
                stack.push(item);
            }else {
                num1 = Integer.parseInt((String) stack.pop());
                num2 = Integer.parseInt((String) stack.pop());
                result = 0;
                if (item.equals("+")){
                    result = num1 + num2;
                }else if (item.equals("-")){
                    result = num2 - num1;
                }else if (item.equals("*")){
                    result = num1 * num2;
                }else if (item.equals("/")){
                    result = num2 / num1;
                }else {
                    throw new RuntimeException("此运算符号无法识别");
                }
                stack.push(result + "");
            }
        }
        return Integer.parseInt((String) stack.pop());
    }

那么如何将中缀表达式转为后缀表达式呢？

1. 初始化两个栈：运算符栈s1和储存中间结果的栈s2；
2. 从左至右扫描中缀表达式；
3. 遇到操作数时，将其压s2；
4. 遇到运算符时，比较其与s1栈顶运算符的优先级：
   4.1 如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
   4.2 否则，若优先级比栈顶运算符的高，也将运算符压入s1；
   4.3 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
5. 遇到括号时：
   5.1 如果是左括号“(”，则直接压入s1
   5.2 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
6. 重复步骤2至5，直到表达式的最右边
7. 将s1中剩余的运算符依次弹出并压入s2
8. 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

代码实现（中缀表达式转后缀表达式）

/***
     * @description: 返回运算符高低的类
     * @param: oper
     * @return: int
     * @author ZhangJiaHao
     * @date: 2021/12/4 9:28
     */
    public static int priority(String oper){
        if (oper == "*" || oper == "/"){
            return 1;
        }else if (oper == "+" || oper == "-"){
            return 0;
        }else {
            return -1; // 认为这是有问题的符号
        }
    }

 /***
     * @description: 将中缀表达式转为对应的List
     * @param: s
     * @return: java.util.List<java.lang.String>
     * @author ZhangJiaHao
     * @date: 2021/12/4 8:54
     */
    public static List<String> toInfixExpressionList(String s){
        List<String> list = new ArrayList<>(); // 定义一个list，存放中缀表达式对应的内容
        int i = 0; // 这是一个指针，用于遍历中缀表达式的字符串
        String str; // 这是对多位数进行拼接的string
        char c; // 每遍历一个字符，就存放到c中
        while (i < s.length()){
            // 如果是非数字，则直接添加到ls中
            if (((c = s.charAt(i)) < 48) || ((c = s.charAt(i)) > 57)){
                list.add(c + "");
                i++;
            }else {
                // 是数字，则判断数字是不是多位数
                str = "";
                while (i < s.length() && ((c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57 )){
                    str = str + c;
                    i++;
                }
                list.add(str);
            }
        }
        return list;
    }

/***
     * @description: 中缀表达式转后缀表达式
     * @param: list
     * @return: java.util.List<java.lang.String>
     * @author ZhangJiaHao
     * @date: 2021/12/4 9:55
     */
    public static List<String> parseSuffixExpressionList(List<String> list){
        // 初始化两个栈
        Stack<String> s1 = new Stack<>(); // 符号栈
        // Stack<String> s2 = new Stack<>(); // 存储中间结果的栈，因为s2在转换的过程中，没有pop的操作，而且到最后还需要逆序的输出，所以我们可以使用ArrayList来代替这个栈
        List<String> s2 = new ArrayList<>();
        // 遍历list
        for (String item : list) {
            // 如果是一个数，则直接入s2
            if (item.matches("\\d+")){
                s2.add(item);
            }else if (item.equals("(")){ // 如果是左括号，则直接入栈
                s1.push(item);
            }else if (item.equals(")")){ // 如果是右括号，则弹出符号栈的值，入s2，直到遇见左括号，然后清楚这对括号
                while (!s1.peek().equals("(")){
                     s2.add(s1.pop());
                }
                s1.pop();
            }else { // 是运算符
                if (s1.size() == 0 || (s1.peek().equals("("))){ //如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈
                    s1.push(item);
                }else if (s1.size() != 0 && (priority(item) > priority(s1.peek())) ){ //若优先级比栈顶运算符的高，也将运算符压入s1
                    s1.push(item);
                }else {
                    // 当item的优先级<=栈顶的运算符的优先级，则弹出栈顶符号并入s2，然后继续比较
                    while (s1.size() != 0 && (priority(item) <= priority(s1.peek()))) {
                        s2.add(s1.pop());
                    }
                    s1.push(item);
                }
            }
        }

        // 将s1的运算符加入到s2中
        while (s1.size() != 0){
            s2.add(s1.pop());
        }
        return s2;

    }

此代码不能满足小数点等操作