中缀表达式转为后缀表达式（逆波兰式）求值
Posted polary
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了中缀表达式转为后缀表达式（逆波兰式）求值相关的知识，希望对你有一定的参考价值。
一、中缀与后缀表达式的介绍
1.中缀表达式
? 中缀表达式是一个通用的算术或逻辑公式表示方法。中缀表达式（或中缀记法）是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。
? 与前缀表达式（例：+ 3 4）或后缀表达式（例：3 4 +）相比，中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法。
? 与前缀或后缀记法不同的是，中缀记法中括号是必需的。计算过程中必须用括号将操作符和对应的操作数括起来，用于指示运算的次序。
例：
（1）8+4-6*2用后缀表达式表示为：
? 8 4+6 2*-
（2）2*(3+5)+7/1-4用后缀表达式表示为：
? 235+*71/+4-
2.后缀表达式（逆波兰式）
? 逆波兰式（Reverse Polish notation，RPN，或逆波兰记法），也叫后缀表达式（将运算符写在操作数之后）
定义
一个表达式E的后缀形式可以如下定义：
（2）如果E是E1 op E2形式的表达式，这里op是任何二元操作符，则E的后缀式为E1‘E2‘ op，这里E1‘和E2‘分别为E1和E2的后缀式。
（3)如果E是（E1）形式的表达式，则E1的后缀式就是E的后缀式。
? 用逆波兰式计算表达式结果的方法为：
- 新建一个表达式
- 判断当前字符
- 如果当前字符为变量或者为数字，则压栈
- 如果是运算符，则将栈顶两个元素弹出作相应运算，结果再入栈
- 最后当表达式扫描完后，栈里的就是结果。
二、待解决问题与解决思路
1.中缀表达式转化为后缀表达式
- 初始化两个栈：运算符栈s1和储存中间结果的栈s2；
- 从左至右扫描中缀表达式；
- 遇到操作数时，将其压s2
- 遇到运算符时，比较其与s1栈顶运算符的优先级
- （1）如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
- （2）否则，若优先级比栈顶运算符的高，也将运算符压入s1；
- （3）否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
- 遇到括号时：
- （1）如果是左括号“(”，则直接压入s1
- （2）如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
- .重复步骤2至5，直到表达式的最右边
- 将s1中剩余的运算符依次弹出并压入s2
- 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
2.后缀表达式进行表达式求值
- 从左到右扫描表达式的字符。
- 对当前字符进行判断
- (1)如果当前字符为运算符，则直接从将栈顶元素和次栈顶元素弹出，与当前运算符进行运算，将结果压入栈中。
- (2)若当前字符为数字，直接压入栈中。
- 循环2.1，2.2直到表达式扫描完毕，最后栈中的数字就是所要的结果。
三、代码实现
/**
* @author ymy
* @date 2020/5/12
*/
public class PolandNotation {
public static void main(String[] args) {
PolandNotation calculate = new PolandNotation();
// System.out.println(calculate.calculateSuffixExpression("30 4 + 5 * 6 -"));
String infix ="1+((2+3)*4)-5";
List<String> list = calculate.toInfixExpressionList(infix);
List<String> suffix= calculate.toSuffixExpression(list);
System.out.print("后缀表达式为：");
String str ="";
for (String s : suffix) {
str+=s;
}
System.out.println("后缀表达式为："+str);
System.out.printf("结果为:%d
",calculate.calculateSuffixExpression(suffix));
}
/**
* @param expressionStr 3 4 + 5 × 6 -
* @return 计算结果
*/
public int calculateSuffixExpression(List<String> expression) {
int res = 0;
Stack<Integer> stack = new Stack();
int num1;
int num2;
String operator = "";
for (int i = 0; i < expression.size(); i++) {
if (isOperaor(expression.get(i))) {
num1 = stack.pop();
num2 = stack.pop();
operator = expression.get(i);
res = calculate(num1, num2, operator);
stack.push(res);
} else {
stack.push(Integer.parseInt(expression.get(i)));
}
}
return res;
}
public int calculate(int num1, int num2, String operator) {
int res = 0;
switch (operator) {
case "+":
res = num1 + num2;
break;
case "-":
res = num2 - num1;
break;
case "*":
res = num1 * num2;
break;
case "/":
res = num2 / num1;
break;
}
return res;
}
public boolean isOperaor(String str) {
return str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/");
}
public int getPriority(String oper){
if (oper.equals("+")||oper.equals("-"))
return 0;
if (oper.equals("*")||oper.equals("/"))
return 1;
return -1;
}
/**
* 将后缀表达式用list保存
*
* @param suffixExpression
* @return
*/
public List<String> getListString(String suffixExpression) {
ArrayList<String> list = new ArrayList();
String[] strings = suffixExpression.split(" ");
for (int i = 0; i < strings.length; i++) {
list.add(strings[i]);
}
return list;
}
/**
* @return 中缀表达式转化为后缀表达式
* 1.初始化两个栈：运算符栈s1和储存中间结果的栈s2；
* 2.从左至右扫描中缀表达式；
* 3.遇到操作数时，将其压s2；
* 4.遇到运算符时，比较其与s1栈顶运算符的优先级：
* (1)如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
* (2)否则，若优先级比栈顶运算符的高，也将运算符压入s1；
* (3)否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
* 5.遇到括号时：
* (1) 如果是左括号“(”，则直接压入s1
* (2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
* 6.重复步骤2至5，直到表达式的最右边
* 7. 将s1中剩余的运算符依次弹出并压入s2
* 8.依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
*
*/
public List<String> toSuffixExpression(List<String> infix) {
LinkedList<String> suffix = new LinkedList<>();
Stack <String> operStack= new Stack();
Stack <String> resStack= new Stack();
String currentCh = "";
for (int i = 0; i <infix.size() ; i++) {
currentCh=infix.get(i);
if(!isOperaor(currentCh)&&!currentCh.equals("(")&&!currentCh.equals(")")){//如果是数字
resStack.push(currentCh);
}else if (isOperaor(currentCh)){//如果是运算符
//若此时运算符栈为空或者栈顶为(，则直接将运算符入栈
while (true){
if (operStack.isEmpty()||operStack.peek().equals("(")){
operStack.push(currentCh);
break;
}else if(getPriority(operStack.peek())<getPriority(currentCh)){
operStack.push(currentCh);
break;
}else {
resStack.push(operStack.pop());
}
}
}else if(currentCh.equals("(")) {
operStack.push(currentCh);
}else if(currentCh.equals(")")){
while (!operStack.peek().equals("(")){
resStack.push(operStack.pop());
}
operStack.pop();
continue;
}else{
throw new RuntimeException("表达式不规范");
}
}
while (!operStack.isEmpty()){
resStack.push(operStack.pop());
}
Stack<String> temp = new Stack<>();
while (!resStack.isEmpty()){
temp.push(resStack.pop());
}
while (!temp.isEmpty()){
suffix.add(temp.pop());
}
return suffix;
}
public List<String> toInfixExpressionList(String string) {
ArrayList<String> infix = new ArrayList<>();
int i = 0;//用来做扫描指针
String str = "";//用来拼接多位数字
char[] chars = string.trim().toCharArray();
System.out.println(chars);
for (int j = 0; j < chars.length; j++) {
if (isNumber(chars[j])) {
str += chars[j];
} else {
if (!str.equals("")){
infix.add(str);
str = "";
}
infix.add(chars[j] + "");
}
}
if (!str.equals("")) {
infix.add(str);
}
return infix;
}
public boolean isNumber(char ch) {
return !("0123456789".indexOf(ch + "") == -1);
}
}
四、运行结果
以上是关于中缀表达式转为后缀表达式（逆波兰式）求值的主要内容，如果未能解决你的问题，请参考以下文章