09 - 逆波兰计算器

Posted liujiaqi1101

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了09 - 逆波兰计算器相关的知识,希望对你有一定的参考价值。

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

  • 前缀表达式的运算符位于操作数之前
    【举例说明】 (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6
  • 前缀表达式的计算机求值
    从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 和 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果
    【举例说明】针对上例的前缀表达式求值步骤如下(栈顶 ? 次顶):
    • 从右至左扫描,将6、5、4、3压入堆栈
    • 遇到 + 运算符,因此弹出3和4(3为栈顶元素,4为次顶元素),计算出3+4的值,得7,再将7入栈
    • 接下来是 × 运算符,因此弹出7和5,计算出7×5=35,将35入栈
    • 最后是 - 运算符,计算出 35-6 的值,即29,由此得出最终结果

2. 中缀表达式

  • 中缀表达式就是常见的运算表达式,如(3+4)×5-6
  • 中缀表达式的求值是我们人最熟悉的,但是对计算机来说却不好操作(08-案例就能看的这个问题),因此,在计算结果时,往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式)

3. 后缀表达式 (逆波兰表达式)

  • 后缀表达式又称逆波兰表达式,与前缀表达式相似,只是运算符位于操作数之后
    【举例说明】 (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –
  • 后缀表达式的计算机求值
    从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 和 栈顶元素),并将结果入栈;重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果
    【举例说明】针对上例的前缀表达式求值步骤如下(次顶 ? 栈顶):
    • 从左至右扫描,将3和4压入堆栈
    • 遇到+运算符,因此弹出4和3(4为栈顶元素,3为次顶元素),计算出3+4的值,得7,再将7入栈
    • 将 5 入栈;
    • 接下来是 × 运算符,因此弹出5和7,计算出7×5=35,将35入栈
    • 将 6 入栈
    • 最后是 - 运算符,计算出35-6的值,即29,由此得出最终结果

4. 中缀表达式 → 后缀表达式

后缀表达式适合计算式进行运算,但是人却不太容易写出来,尤其是表达式很长的情况下。因此在开发中,我们需要将 中缀表达式 → 后缀表达式

4.1 具体步骤

技术图片

4.2 举例

技术图片
技术图片

5. 逆波兰计算器

  • 要求
    • 输入一个逆波兰表达式(后缀表达式),使用栈(Stack), 计算其结果
    • 支持小括号和多位数整数(仅支持对整数的计算)
  • 思路
    • 从左到右遍历逆波兰表达式。遇到数字就入栈;遇到运算符就出栈 [栈顶元素] 和 [次顶元素],用该运算符对其进行运算,之后再将计算结果压栈
    • 遍历结束后,[栈顶元素] 即为 最终表达式结果

6. 代码实现(综合 4, 5)

public class PolandNotaion {
    public static void main(String[] args) {
        String suffixExpression = "(30+4)*5-6";
        List<String> list = parseSuffixExpression(suffixExpression);
        System.out.println("算式结果:" + calculate(list));
    }
    
    // 将 中缀表达式(算式) 由 String → List
    public static List<String> toInfixExpressionList(String str) {
        char[] arr = str.toCharArray();
        // 定义List
        List<String> list = new ArrayList<>();
        // 用于遍历str
        int i = 0; 
        // 用于对多位数的拼接
        String temp = "";
        char c;
        while (i < arr.length) {
            if((c=arr[i]) < 48 || (c=arr[i]) > 57) { // c不是数字
                list.add("" + c);
                i++;
            } else { // c是数字
                while(i < arr.length && (c=arr[i]) >= 48 && (c=arr[i]) <= 57) {
                    temp += c;
                    i++;
                }
                list.add(temp);
                temp = "";
            }
            
            /*
            c = arr[i];
            if(c < 48 || c > 57) { // c不是数字
                list.add("" + c);
            } else { // c是数字
                temp += c;
                if((i+1 != arr.length) && (arr[i+1] < 48 || arr[i+1] > 57)) {
                    list.add(temp);
                    temp = "";
                }
            }
            i++;
            */
        }
        return list;
    }
    
    // 中缀表达式List → 后缀表达式List
    public static List<String> parseSuffixExpression(String infixExpression) {
        // 中缀表达式的字符串 → List
        List<String> infixExpressionList = toInfixExpressionList(infixExpression);
        // 定义 [运算符栈s1]
        Stack<String> s1 = new Stack<>();
        /* 
         * 定义 [存储中间结果的栈s2]
         *  解释:s2这个栈, 在整个过程中没有pop操作, 而且在末尾还需要逆序输出
         * 不如 直接使用一个List来替代s2的栈结构
         */
        List<String> s2 = new ArrayList<>();
        // 遍历infixExpressionList
        for(String item : infixExpressionList) {
            if(item.matches("d+")) { // 是数, 加入s2
                s2.add(item);
            } else if(s1.isEmpty() || item.equals("(")) {
                s1.push(item);
            } else if(item.equals(")")) {
                // 依次弹出 s1 栈顶的运算符,并压入 s2
                while(!s1.peek().equals("(")) { // 直到遇到 " ( " 为止
                    s2.add(s1.pop());
                }
                s1.pop(); // 将 "(" 弹出, 即将这对括号丢弃
            } else {
                // 运算符优先级 ≤ 栈顶运算符优先级
                while(s1.size() > 0 && getPriority(item) <= getPriority(s1.peek())) {
                    // 将 {栈顶运算符} 弹出并压入 s2 中
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
        }
        // 将 s1 中剩余的运算符 依次弹出 并加入 s2
        while(s1.size() != 0) 
            s2.add(s1.pop());
        // 依次弹出 s2 中的元素并输出,结果的逆序即为 中缀表达式对应的后缀表达式
        // 因为 s2 是List, 所以存放的顺序就是最终后缀表达式的顺序
        return s2;
    }   
    
    // 返回运算符优先级(拟定为:优先级使用数字表示, 数字越大, 则优先级越高)
    public static int getPriority(String operation) {
        int val = 0;
        switch (operation) {
        case "+":
            val = 1;
            break;
        case "-":
            val = 1;
            break;
        case "*":
            val = 2;
            break;
        case "/":
            val = 2;
            break;
        default:
            System.out.println("不存在该运算符" + operation);
            break;
        }
        return val;
    }
    
    // 完成对逆波兰表达式的计算
    public static int calculate(List<String> list) {
        // 创建栈(仅需1个栈即可)
        Stack<String> stack = new Stack<String>();
        // 遍历list
        for(String item : list)
            // 这里使用 [正则表达式] 来取数
            if(item.matches("d+")) { // --> 匹配 多位数
                // 入栈
                stack.push(item);
            } else { // --> 匹配 运算符
                // 弹出 栈顶元素 和 次顶元素, 并通过此次扫描到的运算符进行运算
                int topNum = Integer.parseInt(stack.pop());
                int nextTopNum = Integer.parseInt(stack.pop());
                // 解析运算符 (次顶 ___ 栈顶)
                int result;
                if(item.equals("+"))
                    result = nextTopNum + topNum;
                else if(item.equals("-"))
                    result = nextTopNum - topNum;
                else if(item.equals("*"))
                    result = nextTopNum * topNum;
                else if(item.equals("/"))
                    result = nextTopNum / topNum;
                else 
                    throw new RuntimeException("运算符有误");
                // 将结果再次入栈
                stack.push(result + "");
            }
        return Integer.parseInt(stack.pop());
    }
}

以上是关于09 - 逆波兰计算器的主要内容,如果未能解决你的问题,请参考以下文章

09 - 逆波兰计算器

逆波兰计算器

逆波兰计算器

C++栈的应用:逆波兰式的实现

python实现逆波兰计算表达式的代码

算法与数据结构--栈的应用-逆波兰计算器完整版代码