栈--逆波兰表达式求值

栈–逆波兰表达式求值

中缀表达式：

​ 中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总是置于两个操作数中间。

​ 中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作

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

​ 逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表达式的特点：运算符总是放在跟它相关的操作数之后。

中缀表达式	逆波兰表达式(后缀表达式)
a+b	ab+
a+(b-c)	abc-+
a+(b-c)*d	abc-d*+
a*(b-c)+d	abc-*d+

需求：

​ 给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方式，求出该逆波兰表达式的结果。

分析：

1.创建一个栈对象oprands存储操作数

2.从左往右遍历逆波兰表达式，得到每一个字符串

3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中

4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2

5.使用该运算符计算o1和o2，得到结果result

6.把该结果压入oprands栈中

7.遍历结束后，拿出栈中最终的结果返回

代码实现：

/**
 * 栈--逆波兰表达式
 */
public class ReversePolishNotation {
    public static void main(String[] args) {
        //中缀表达式3*（17-15）+18/6的逆波兰表达式如下 结果为9
        String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
        int result = caculate(notation);
        System.out.println("逆波兰表达式的结果为：" + result);
    }

    /**
     * @param notaion 逆波兰表达式的数组表示方式
     * @return 逆波兰表达式的计算结果
     */
    public static int caculate(String[] notaion) {
        // 定义栈，存储操作数，
        Stack<Integer> oprands = new Stack<>();
        // 遍历逆波兰表达式，得到每一个元素
        for (int i = 0; i < notaion.length; i++) {
            String curr = notaion[i];
            Integer o1;
            Integer o2;
            Integer result;
            // 判断当前元素是否为运算符。是，则从栈中取出两个操作数进行运算后，将结果存入栈中。不是，则为操作数，存入栈中
            switch (curr) {
                case "+":
                    // 从栈中取出两个操作数，进行运算，并将结果存入栈中（注意操作数取值的先后，后取的值为，运算符左侧的操作数）
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 + o1;
                    oprands.push(result);
                    break;
                case "-":
                    // 从栈中取出两个操作数，进行运算，并将结果存入栈中（注意操作数取值的先后，后取的值为，运算符左侧的操作数）
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 - o1;
                    oprands.push(result);
                    break;
                case "*":
                    // 从栈中取出两个操作数，进行运算，并将结果存入栈中（注意操作数取值的先后，后取的值为，运算符左侧的操作数）
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 * o1;
                    oprands.push(result);
                    break;
                case "/":
                    // 从栈中取出两个操作数，进行运算，并将结果存入栈中（注意操作数取值的先后，后取的值为，运算符左侧的操作数）
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 / o1;
                    oprands.push(result);
                    break;
                default:
                    // 当前元素为运算数，直接存入栈中
                    oprands.push(Integer.parseInt(curr));
                    break;
            }
        }
        // 循环完毕，将栈准备的结果返回
        return oprands.pop();
    }
}