前缀、中缀、后缀(逆波兰)表达式

前缀表达式

(3+4)*5-6对应的前缀表达式就是[- * + 3 4 5 6]。

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

例如：(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，得35入栈。
4. 最后是-运算符，计算出35-6，即结果29。

中缀表达式

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

后缀表达式

• 后缀表达式又称逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后。
• 举例：(3+4)*5-6对应的后缀表达式就是[3 4 + 5 * 6 -]。

正常表达式	后缀表达式
a+b	a b +
a+(b-c)	a b c - +
a+(b-c)*d	a b c - d * +
a+d*(b-c)	a d b c - * +
a=1+3	a 1 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，入栈；
5. 将6入栈；
6. 最后是-运算符，计算出结果29。

逆波兰计算器代码实现

package dataStructs.stack;

import org.omg.CORBA.StringHolder;

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

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

        //完成将一个中缀表达式转成后缀表达式的功能
        String expression = "1+((2+3)*4)-5";

        List<String> list = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的list"+list);

        List<String> strings = parseSuffixExpressionList(list);
        System.out.println("后缀表达式对应的list"+strings);

        System.out.printf("expression=%d",calculate(strings));

    }

    public static List<String> parseSuffixExpressionList(List<String> ls){

        Stack<String> s1 = new Stack<>();//符号栈
        List<String> s2 = new ArrayList<>();//存放中间结果

        for (String item : ls){
            //如果是一个数，存入s2
            if(item.matches("\\d+")){
                s2.add(item);
            } else if(item.equals("(")){
                s1.push(item);
            } else if (item.equals(")")){
                //如果是右括号，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while (!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();
            } else {
                //当item的优先级小于等于s1栈顶运算符，将s1栈顶的运算符弹出并加入到s2中
                while (s1.size()!=0 && Operation.getValue(s1.peek())>=Operation.getValue(item)){
                    s2.add(s1.pop());
                }
                //还需要将item压入栈
                s1.push(item);
            }
        }


        while (s1.size()!=0){
            s2.add(s1.pop());
        }

        return s2;

    }


    //将中缀表达式转成对应的list
    public static List<String> toInfixExpressionList(String s){

        //定义list，存放中缀表达式的数据
        List<String> ls = new ArrayList<String>();
        int i = 0;
        String str;

        char c;

        do {
            //如果c是一个非数字
            if((c=s.charAt(i))<48 || (c=s.charAt(i))>57){
                ls.add(""+c);
                i++;
            }else {
                str = "";
                while (i < s.length() && (c=s.charAt(i))>=48 && (c=s.charAt(i))<=57){
                    str += c;
                    i++;
                }
                ls.add(str);
            }
        }while (i<s.length());

        return ls;
    }


    //将一个逆波兰表达式，依次将数据和运算符放入到ArrayList中
    public static List<String> getListString(String suffixExpression){
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
        for (String ele : split){
            list.add(ele);
        }

        return list;
    }

    public static int calculate(List<String> ls){
        Stack<String> stack = new Stack<>();

        //遍历ls
        for (String item : ls){
            //正则判断是否是数字
            if(item.matches("\\d+")){
                //入栈
                stack.push(item);
            }else{
                //pop出两个数，并运算,再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());

                int res = 0;
                if(item.equals("+")){
                    res = num1 + num2;
                }else if(item.equals("-")){
                    res = num1 - num2;
                }else if(item.equals("*")){
                    res = num1 * num2;
                }else if(item.equals("/")){
                    res = num1 / num2;
                }else {
                    throw new RuntimeException("运算符有误");
                }

                stack.push(res+"");
            }
        }

        //最后留在stack中的数据是运算结果
        return Integer.parseInt(stack.pop());

    }
}

//判断优先级
class Operation{
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    //返回对应的优先数字
    public static int getValue(String operation){
        int result = 0;
        switch (operation){
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
        }

        return result;
    }

}