中缀表达式、前缀表达式、后缀表达式

前缀表达式、中缀表达式、后缀表达式

1）中缀表达式：操作运算符在操作数中间
（3+2）*4-6

2）前缀表达式：波兰式，操作运算符在操作数之前，
如-*+3246。
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 op 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果

• 中缀表达式 ----> 前缀表达式:

       - 初始化两个栈，符号栈s1、存放中间结果栈s2
       - **从右至左扫描**中缀表达式
       - 遇到操作数，将其压入栈s2
       - 遇到操作运算符，则需要比较其与s1栈顶操作符的优先级
       			1.若s1为空，或者栈顶运算符为**右括号）**，则直接入栈
       			2.优先级高于栈顶运算符，也直接入栈
       			3.否则，将s1栈顶运算符弹出压入s2，再转到步骤1进行判断
       - 遇到括号：
                  1.如果遇到**右括号**，直接压入栈
                  2.如果遇到**左括号**，则依次弹出s1栈顶运算符，压入s2，直到遇到右括号为止，并将这一对括号丢弃
   	- 重复2-5，直至表达式左边
   	- 将s1中剩余运算符依次弹出并压入s2
   	- 依次弹出s2的元素，即为中缀表达式
  

例如:1+((2+3)×4)-5具体过程，如下表
| 扫描到的元素 | 中间结果栈s2（栈底->栈顶） |运算符栈s1（栈底->栈顶） |说明 |
|–|–|–|–|–|
|5| 5 |空 |数字直接入栈s2 |
|-| 5 |- |运算符栈s1空，所以-直接入栈s2 |
|）| 5 |-) |右括号直接入栈s1 |
|4| 54 |- |数字直接入栈s2 |
|x| 54|-)x |符号栈顶为右括号，所以直接入栈s2 |
|）| 54 |-)x） |右括号直接入栈s1 |
|3| 543 |-)x） |数字直接入栈s2 |
|+| 543 |-)x）+ |符号栈顶为右括号，所以直接入栈s1 |
|2| 5432 |-)x）+ |数字直接入栈s2 |
|(| 5432+ |-)x |左括号，所以将栈s1从顶部弹出元素，知道碰到右括号，同时将弹出的压入s2，另外这对括号将被抛弃 |
|(| 5432+x |- |左括号，所以将栈s1从顶部弹出元素，知道碰到右括号，同时将弹出的压入s2，另外这对括号将被抛弃 |
|+| 5432+x |-+ |+优先级和-优先级一样，所以直接入栈s1|
|1| 5432+x1 |-+ |数字直接入栈s2|

将栈s1中剩余的依次弹出，并压入s2，得到 5432+x1+ -
最后将s2中依次弹出-+1x+2345

• 计算机计算值：

    - 表达式： -*+3246
      		- 从右至左扫描前缀表达式，依次将6、4、2、3依次压入堆栈
    		- 遇到运算符 + ，弹出栈顶和次栈顶的两个数3、2，计算3+2的值为5，压入栈
    		- 遇到*，依次弹出5、4，计算5*4为20，再将20压入堆栈
    		- 遇到-，依次弹出20、6，计算20-6为14，即最后结果。
  

3）后缀表达式（逆波兰式）：操作运算符在操作数之前，
如3 4 + 5 × 6 -。与前缀表达式类似，区别是从左至右扫描。
从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 op 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

• 中缀表达式 ----> 后缀表达式:

        - 初始化两个栈，符号栈s1、存放中间结果栈s2
        - **从左至右**扫描中缀表达式
        - 遇到操作数，将其压入栈s2
        - 遇到操作运算符，则需要比较其与s1栈顶操作符的优先级
        			1.若s1为空，或者栈顶运算符为**左括号（**，则直接入栈
        			2.优先级高于栈顶运算符，也直接入栈
        			3.否则，将s1栈顶运算符弹出压入s2，再转到步骤1进行判断
        - 遇到括号：
                   1.如果遇到**左括号**，直接压入栈
                   2.如果遇到**右括号**，则依次弹出s1栈顶运算符，压入s2，直到遇到右括号为止，并将这一对括号丢弃
    	- 重复2-5，直至表达式右边
    	- 将s1中剩余运算符依次弹出并压入s2
    	- 依次弹出s2的元素，即为中缀表达式
  

例如:1+((2+3)×4)-5具体过程，如下表
| 扫描到的元素 | 中间结果栈s2（栈底->栈顶） |运算符栈s1（栈底->栈顶） |说明 |
|–|–|–|–|–|
|1| 1 |空 |数字直接入栈s2 |
|+| 1 |+ |运算符栈s1空，所以-直接入栈s2 |
|（| 1 |+（ |左括号直接入栈s1 |
|（| 1|+（（ |数字直接入栈s2 |
|2| 12|+（（ |符号栈顶为左括号，所以直接入栈s2 |
|+| 12 |+（（+ |右括号直接入栈s1 |
|3| 123 |+（（+ |数字直接入栈s2 |
|）| 123+ |+（ |符号栈顶为左括号，所以直接入栈s1 |
|x| 123+ |+(x |数字直接入栈s2 |
|4| 123+4 |+(x |数字直接入栈s2 |
|)| 123+4x |+ |右括号，所以从s1栈顶弹出元素并压入s2，直到遇到左括号，并且将这对括号抛弃|
|-| 123+4x |± |相同优先级，直接压入|
|5| 123+4x5 |± |数字，直接压入s2|

将栈s1中剩余的依次弹出，并压入s2，得到123+4x5-+（栈底->栈顶）
最后将s2中依次弹出±5x4+321
逆序 123+4x5-+，即为后缀表达式

• 计算机计算值：

   - 表达式：3 4 + 5 × 6 -
     		- 从左至右扫描后缀表达式，依次将3、4依次压入堆栈
   		- 遇到运算符 + ，弹出栈顶和次栈顶的两个数4、3，计算4+3的值为7，压入栈
   		- 遇到5，入栈
   		- 遇到x，弹出栈顶和次栈顶的两个数5、7，计算7*5=35，入栈
   		- 遇到6，入栈
   		- 遇到-，弹出栈顶和次栈顶的两个数6、36，计算35-6=29
  

# java
public class Operation {
    private static int ADDITION=1;
    private static int SUBTRACTION=1;
    private static int MULTIPLICATION=2;
    private static int DIVISION=2;

    public static int getValue(String operation){
        int result;
        switch (operation){
            case "+":
                result=ADDITION;
                break;
            case "-":
                result=SUBTRACTION;
                break;
            case "*":
                result=MULTIPLICATION;
                break;
            case "/":
                result=DIVISION;
                break;
            default:
//                System.out.println("不存在该运算符");
                result=0;
        }
        return result;
    }
}



public class PolishNotation {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入运算表达式:");
        String expressionStr=sc.nextLine();
//        System.out.println(expressionStr);
        List<String> zx= toInfixExpression(expressionStr);
        List<String> rpn=parseSuffixExpression(zx);
        String rpnStr="";
        for(String str:rpn){
            rpnStr+=str;
        }
        System.out.println(rpnStr);

        System.out.println("计算结果:"+ calculate(rpn));
    }

    /**
     * 把字符串转换成中序表达式
     * @param s
     * @return
     */
    public static List<String> toInfixExpression(String s) {
        List<String> ls = new ArrayList<String>();//存储中序表达式
        int i = 0;
        String str;
        char c;
        do {
            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;
    }

    /**
     * 转换成逆波兰表达式
     * @param ls
     * @return
     */
    public static List<String> parseSuffixExpression(List<String> ls) {
        Stack<String> s1=new Stack<String>();
        Stack<String> s2=new Stack<String>();
        List<String> lss = new ArrayList<String>();
        for (String ss : ls) {
            if (ss.matches("\\d+")) {
                lss.add(ss);
            } else if (ss.equals("(")) {
                s1.push(ss);
            } else if (ss.equals(")")) {

                while (!s1.peek().equals("(")) {
                    lss.add(s1.pop());
                }
                s1.pop();
            } else {
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(ss)) {
                    lss.add(s1.pop());
                }
                s1.push(ss);
            }
        }
        while (s1.size() != 0) {
            lss.add(s1.pop());
        }
        return lss;
    }

    /**
     * 通过逆波兰表达式计算结果
     * @param ls
     * @return
     */
    public static int calculate(List<String> ls) {
        Stack<String> s=new Stack<String>();
        for (String str : ls) {
            if (str.matches("\\d+")) {
                s.push(str);
            } else {
                int b = Integer.parseInt(s.pop());
                int a = Integer.parseInt(s.pop());
                int result=0;
                if (str.equals("+")) {
                    result = a + b;
                } else if (str.equals("-")) {
                    result = a - b;
                } else if (str.equals("*")) {
                    result = a * b;
                } else if (str.equals("\\")) {
                    result = a / b;
                }
                s.push("" + result);
            }
        }
        System.out.println(s.peek());
        return Integer.parseInt(s.pop());
    }
}

参考https://www.cnblogs.com/chensongxian/p/7059802.html