一、前缀表达式
-
前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前 如：(3+4) x 5-6 对应的前缀表达式就是 - x + 3 4 5 6
-
前缀表达式的计算机求值： 从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们做相应的计算(栈顶元素和次顶元素)，并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果 如：(3+4) x 5-6 对应的前缀表达式就是 - x + 3 4 5 6 ，针对前缀表达式求值步骤如下： 1）从右至左扫描，将6、5、4、3压入堆栈 2）遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得到7，在将7入栈 3）接下来是x运算符，因此弹出7和5，计算出7x5=35，将35入栈 4）最后是-运算符，计算出35-6的值，即29，由此得出最终结果 29。
二、中缀表达式
- 中缀表达式就是常见的运算符表达式，如 (3+4) x 5-6
- 中缀表达式的求值是我们人们最熟悉的，但是对计算机来说却不好操作，因此在计算结果时，往往会将中缀表达式转换成其他表达式来操作(一般会转成后缀表达式)。
三、后缀表达式（逆波兰表达式）
- 后缀表达式又称 逆波兰表达式 与前缀表达式相似，只是运算符位于操作数之后
- 如：(3+4) x 5-6对应的后缀表达式就是 3 4 + 5 x 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) x 5-6 对应的后缀表达式就是 3 4 + 5 x 6 -，针对前缀表达式求值步骤如下： 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，由此得出结果 29。
四、中缀表达式转换为后缀表达式
后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将中缀表达式转成后缀表达式。
具体步骤如下：
- 初始化两个栈：运算符栈s1和存储中间结果的栈s2；
- 从左至右扫描中缀表达式；
- 遇到操作数时，将其压入s2；
- 遇到运算符时，比较其与s1栈顶运算符的优先级：
- 如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
- 否则，若优先级比栈顶运算符的高，也将运算符压入s1；
- 否则，将s1栈顶的运算符弹出并压入s2中，再次转到4.1步骤与s1中新的栈顶运算符相比较；
- 遇到括号时：
- 如果是左括号“(”，则直接压入s1；
- 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃；
- 重复步骤2-5，直到表达式的最右边。
- 将s1中剩余的运算符依次弹出并压入s2
- 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式。
转换过程
将中缀表达式 "1+((2+3)*4)-5" 转换为后缀表达式的过程如下：
结果为："1 2 3 + 4 * 5 - "
PolandNotation.java
package top.snailstudy.stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolandNotation {
public static int calculate(List<String> ls){
Stack<String> stack = new Stack<String>();
for (String item : ls) {
if(item.matches("\\d+")){ //"\\d+"匹配多为数字
stack.push(item);
}else{
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);
}
}
return Integer.parseInt(stack.pop());
}
//将中缀表达式转换成对应的List
public static List<String> toInfixExpr(String s){
ArrayList<String> ls = new ArrayList<String>();
int i = 0; //这时是一个指针，用于遍历中缀表达式字符串
String str; //对多位数的拼接
char c; //每遍历到一个字符，就放入到c
do {
//如果c是一个非数字，需要加入到ls
if((c = s.charAt(i)) < 48 || (c=s.charAt(i)) > 57){
ls.add(""+c);
i++; //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;
}
//将得到的中缀表达式List 转成 后缀表达式
public static List<String> parseSuffixExpreesion(List<String> ls){
//定义两个栈
Stack<String> stack = new Stack<String>(); //符号栈
ArrayList<String> s2 = new ArrayList<String>();
for (String item : ls) {
//如果是一个数，添加到s2
if(item.matches("\\d+")){
s2.add(item);
}else if("(".equals(item)){
stack.push(item);
}else if(")".equals(item)){
while (!"(".equals(stack.peek())){
s2.add(stack.pop());
}
stack.pop();//将(小括号弹出去，消除小括号
}else {
//优先级小于等于stack栈顶运算符
while (stack.size() != 0 && Operation.getValue(stack.peek()) >= Operation.getValue(item)){
s2.add(stack.pop());
}
//需要将item压入栈中
stack.push(item);
}
}
//将stack中剩下的弹出并加入到s2中
while (stack.size() != 0){
s2.add(stack.pop());
}
return s2;
}
public static void main(String[] args) {
String expression = "1+((2+3)*4)-5";
List<String> list = toInfixExpr(expression);
System.out.println("中缀表达式对应的list="+list);
List<String> suffixExpreesion = parseSuffixExpreesion(list);
System.out.println("后缀表达式对应的suffixExpreesion="+suffixExpreesion);
int calculate = calculate(suffixExpreesion);
System.out.println("1+((2+3)*4)-5 ="+ calculate);
}
}
//返回一个运算符对应的优先级
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;
}
}
输出结果： 中缀表达式对应的list=[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5] 不存在该运算符 不存在该运算符 后缀表达式对应的suffixExpreesion=[1, 2, 3, +, 4, *, +, 5, -] 1+((2+3)*4)-5 =16
