数据结构与算法-使用栈《逆波兰表达式求值问题》

Posted 2021-08-15 闲言_

问题描述

中缀表达式：3*(17-15)+18/6
给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方式，求出该逆波兰表达式的结果。
String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};

解决思路

1. 创建一个栈对象用于存储操作数
2. 遍历逆波兰表达式数组，得到每一个字符
3. 判断该字符是不是 运算符，如果不是，则压入栈中
4. 如果是运算符，则从栈中弹出两个操作数：o1 o2
5. 使用该运算符计算o1和o2，然后将计算的结构压入栈中
6. 遍历结束数返回栈中最后的元素

注意：
  在做 减法运算 和 除法运算时，需要特别注意，应该是用前面的数 减去 或除去 后面的数，因为栈是先进后出原则。所有在做 减法运算 和 除法运算时需要交换 弹栈的元素 位置

代码如下

输出结果

逆波兰表达式的结过为：9

代码

package cn.bloghut;

/**
 * @author by 闲言
 * @classname ReversePolishNotation
 * @description 解决逆波兰表达式问题
 * @date 2021/7/18 10:00
 */
public class ReversePolishNotation {
    public static void main(String[] args) {
        //中缀表达式3*(17-15)+18/6的逆波兰表达式如下
        String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
        System.out.println("逆波兰表达式的结过为：" + caculate(notation));
    }

    /**
     * 计算逆波兰表达式的方法
     *
     * @param notation 逆波兰表达式的数组表示方式
     * @return 逆波兰表达式的计算结果
     */
    public static int caculate(String[] notation) {
        //1.定义一个栈，用来存储操作数
        Stack<Integer> stack = new Stack<>();
        //2.从左往右遍历逆波兰表达式，得到每一个元素
        for (String str : notation) {
            char charAt = str.charAt(0);
            //3.判断当前元素是运算符还是操作数
            Integer o1;
            Integer o2;
            switch (charAt) {
                //4.运算符，从栈中弹出两个操作数，完成运算，运算完的结构再压入栈中
                case '-':
                    //应该是前面的数 减去 后面的数
                    //而栈是先进后出原则，先弹出的元素（o1） 后弹出的元素（o2） 顺序应该交换
                    //所以就是 o2 - o1
                    o1 = stack.pop();
                    o2 = stack.pop();
                    stack.push(o2 - o1);
                    break;
                case '+':
                    o1 = stack.pop();
                    o2 = stack.pop();
                    stack.push(o2 + o1);
                    break;
                case '*':
                    o1 = stack.pop();
                    o2 = stack.pop();
                    stack.push(o2 * o1);
                    break;
                case '/':
                    o1 = stack.pop();
                    o2 = stack.pop();
                    //应该是前面的数除于后面的数
                    //而栈是先进后出原则，先弹出的元素（o1） 后弹出的元素（o2） 顺序应该交换
                    //所以就是 o2 / o1
                    stack.push(o2 / o1);
                    break;
                default:
                    //5.操作数，把操作数压入栈中
                    stack.push(Integer.parseInt(str));
                    break;
            }
        }
        //6.得到栈中最后一个元素，就是逆波兰表达式的结果
        return stack.pop();
    }

}