前缀、中缀、后缀表达式（逆波兰表达式分析与实现）

一、前缀表达式

从右至左扫描表达式：

1、遇到数字时，将数字压入堆栈；

2、遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(栈项元素和次顶元素)，并将结果入栈;

3、重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。

【举例】
( 3 +4 ) * 5 - 6 对应的前缀表达式 - * + 3 4 5 6
步骤如下：
（1）、从右至左扫描，将6、5、4、3压入堆栈；

（2）、遇到+运算符，因此弹出3和4 (3为栈顶元素，4为次顶元素)，计算出3+4的值，得7,再将7入栈；

（3）、接下来是运算符，因此弹出7和5，计算出75=35，将35入栈；

（4）、最后是-运算符，计算出35-6的值，即29，即为最终结果。

二、中缀表达式

1、中缀表达式就是常见的运算表达式，如(3+4)*5-6；

2、 中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作(上一个博客写过代码)，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作。（常见的操作是：中缀表达式转后缀表达式）。

三、后缀表达式

1、后缀表达式又称逆波兰表达式，运算符位于操作数之后。

2、举例说明: ( 3 + 4 ) * 5 - 6 对应的后缀表达式 3 4 + 5 * 6 -

3、一些转后缀表达式的例子：

① a + b → a b +

② a + ( b - c ) → a b c - +

③ a + d * ( b - c ) → a d b c - * +

④ a = 1 + 3 → a 1 3 + =

⑤ a + ( b - c ) * d → a b c - d * +

那么如何实现逆波兰表达式呢？

从左至右扫描表达式：

1、遇到数字时，将数字压入堆栈;

2、遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(次项元素和栈项元素)，并将结果入栈;

3、重复上述过程直到表达式最右，最后运算得出的值即为表达式的结果。

【举例】

( 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，计算出75=35，将35入栈;

（5）、将6入栈;

（6）、 最后是-运算符，计算出35-6的值， 即29，即为最终结果。

具体代码实现如下：

package com.ycx.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
    public static void main(String[] args) {

        //先定义一个逆波兰表达式：(3+4)*5-6  =>  3 4 + 5 * 6 -
        //测试
        // 4 * 5 - 8 + 60 + 8 / 2=> 4 5 * 8 - 60 + 8 2 /
        //为了方便，逆波兰表达式的数字和符号使用空格隔开


         String expression = "30 4 + 5 * 6 -";

        /*
            思路：
               1、将"3 4 + 5 * 6 -" 放到ArrayList中
               2、将ArrayList传递给一个方法，遍历ArrayList，配合栈完成计算
         */

        List<String> list1 = getListString(expression);//放在List中方便取数，如果用index索引 需要一个一个的扫描,比较麻烦
        System.out.println("list1 =" + list1);

        int result1 = calculate(list1);
        System.out.println("计算结果是："+ result1);
    }

    //将一个逆波兰表达式，依次将数据和运算符 放到ArrayList中
    public static List<String> getListString(String expression){
        //将expression用空格分割
        String[] split = expression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele : split){ //对split进行for循环 每循环一次就取出波兰表达式中的一个元素
            list.add(ele);
        }
        return list;
    }

    /*
       完成逆波兰表达式的步骤：
      1) 从左至右扫描，将3和4压入堆栈;
      2) 遇到+运算符， 因此弹出4和3 (4为栈顶元素，3为次顶元素)，计算出3+4的值，得7，再将7入栈;
      3) 将5入栈;
      4) 接下来是X运算符，因此弹出5和7，计算出7X5=35，将35入栈;
      5) 将6入栈;
      6) 最后是-运算符，计算出35-6的值， 即29，由此得出最终结果
    */

    public  static int calculate(List<String> list2){
        //创建栈
        Stack<String> stack = new Stack<String>();
        //遍历list2
        for (String ele1:list2){
            if(ele1.matches("\\d+")){ //正则表达式：匹配多位数
                //如果是数就入栈
                stack.push(ele1);
            }else {   //如果是字符 就pop出两个数 进行运算
                int num1 = Integer.parseInt(stack.pop()); //stack.pop() 出来的是字符 需要转化成数字
                int num2 = Integer.parseInt(stack.pop());//num2 比 num1 后 pop出 所以注意减法和除法时的顺序
                int result = 0;
                if(ele1.equals("+")){
                    result = num1 + num2;
                }else if(ele1.equals("-")){
                    result = num2 - num1;
                }else if(ele1.equals("*")){
                    result = num1 * num2;
                }else if(ele1.equals("/")){
                    result = num2 / num1;
                }else {
                    throw  new RuntimeException("运算符有误");
                }
                //结果入栈
                stack.push(result+"");//整数转化为字符串
            }
        }
        //最后留在stack中的是运算结果
        return Integer.parseInt(stack.pop());
    }
}

运行结果如下：