问题描述

程序设计中经常使用表达式，现在需要编写程序，设计算法，利用栈，计算合法表达式结果。本题中表达式由含运算符+、-、*、/、(、)和整形常量复合而成。

程序代码

package com.company;
import java.util.Scanner;
import java.util.Stack;
public class Main {
public static String convert2Postfix(String infix) {
char[] chars = infix.toCharArray(); //转换为字符数组
Stack stack = new Stack(); //存放操作符
StringBuilder ans = new StringBuilder(infix.length()); //存放后缀表达式。用stringBuilder方便拼接
Character ch;
for (int i=0;i
Character c = chars[i];
switch (c) {
case '(':
stack.push(c);
break; //左括号直接入栈
case '*':
case '/':
while (!stack.isEmpty()) {
ch = stack.pop();
if (getPriority(ch) < 2) { //为 + - 操作或者 ( 的时候
stack.push(ch);
break;
} else ans.append(" " + ch);
}
stack.push(c);
ans.append(" ");
break;
case '+':
case '-':
Boolean a2 = (i != 0) && (c == '-') && (Character.isDigit(chars[i - 1])); //表示-号前面为数字的时候
Boolean a3 = (i != 0) && (c == '-') && (chars[i - 1] == ')'); //表示-号前面为)的时候
Boolean a4 = (i != 0) && (c == '-') && (chars[i - 1] == '(');
if(a2.booleanValue() || a3.booleanValue() || c == '+') { //表示这是操作符意义上的-号或者这是加号
while (!stack.isEmpty()) {
ch = stack.pop();
if (ch == '(') { //+-的时候优先级比它低的只有(
stack.push('(');
break;
}
ans.append(" " + ch);
}
stack.push(c);
ans.append(" ");
break;
}else if(a4.booleanValue() || Character.isDigit(chars[i + 1])) { //@更新之处：此时一定是(-23)这样的，我们当然是直接把符号加在字符串末尾，那么就能和后面的数字直接解释成负数
ans.append("-");
}else { //@更新之处：此时一定是减号-(，且表达式一开始就是减号-，找到被()包括起来的数字
ans.append("0 ");
StringBuilder tmp = new StringBuilder();
int j;
for(j=i+1;j
tmp.append(chars[j]);
if(chars[j] == ')') {
break;
}
}
i = j;
// System.out.println("I am tmp " + tmp);
ans.append(convert2Postfix(tmp.toString()) + " -");
}
case ')':
while(!stack.isEmpty()){
ch = stack.pop();
if(ch =='(')
break;
else
ans.append(" " + ch);
} //直到出现(号停止弹出
break;
default:
ans.append(c); //普通数字字符直接拼接到后缀表达式里面
}
}
while (!stack.empty()) {
ans.append(" " + stack.pop());
}
return ans.toString();
}
public static int getPostfixValue(String postfix) {
String[] tokens = postfix.split(" "); //将后缀表达式按照空格分开
// System.out.println(postfix);
Stack stack = new Stack();
int value = 0;
int factor = 1;
for (String c : tokens) {
if (c.length() != 1 || Character.isDigit(c.charAt(0))) { //如果长度不等于1(包括-1)或者说长度为1的数就压入到栈里
stack.push(Integer.parseInt(c));
} else if (c.length() == 1 && isOperator(c.charAt(0))) { //为操作符的时候
int op1 = stack.pop();
int op2 = stack.pop();
int result;
switch (c.charAt(0)) {
case '*':
result = op1 * op2;
stack.push(result);
break;
case '/':
result = op2 / op1;
stack.push(result);
break;
case '+':
result = op1 + op2;
stack.push(result);
break;
case '-':
result = op2 - op1;
stack.push(result);
break;
}
}
}
return stack.pop() * factor;
}
private static int getPriority(char operator) {
int t = 0;
if (operator == '-' || operator == '+') {
t = 1;
} else if (operator == '*' || operator == '/') {
t = 2;
}
return t;
}//获取优先级
private static boolean isOperator(char x) {
if(x == '-' || x == '+' || x == '*' || x == '/')
return true;
else
return false;
}//判断是否为操作符
public static void main(String[] args)
{
Scanner cin = new Scanner(System.in);
String expression = cin.nextLine();
System.out.println(getPostfixValue(convert2Postfix(expression)));
}//主程序
}

程序说明

将中缀表达式转换为后缀表达式后进行计算，以下引自百度百科

a. 若为 '('，入栈；

b. 若为 ')'，则依次把栈中的的运算符加入后缀表达式中，直到出现'('，从栈中删除'(' ；

c. 若为 除括号外的其他运算符， 当其优先级高于除'('以外的栈顶运算符时，直接入栈。否则从栈顶开始，依次弹出比当前处理的运算符优先级高和优先级相等的运算符，直到一个比它优先级低的或者遇到了一个左括号为止。

·当扫描的中缀表达式结束时，栈中的的所有运算符出栈;

转换成后缀表达式再进行相应计算，详见注释

更新日志

2021-1-28

感谢评论区指出的一个小bug，问题在于如果出现-(1+2)这样的式子本来我是没有考虑到的

处理的方案是在将中追表达式->后缀表达式的时候将其看成0-(1+2)这样再转化为对应的后缀表达式也就是0 1 2 + -，这样就能很好的处理这样的式子了

转换的关键在于找到被(和)包括起来的部分的式子，这里是用for循环来找)