前缀表达式：波兰式，操作运算符在操作数之前
中缀表达式：操作运算符在操作数中间
后缀表达式：(逆波兰表达式)运算符位于操作数之后
逆波兰表达式
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
例如: (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，计算出7×5=35，将35入栈
4.最后是-运算符，计算出35-6的值，即29，由此得出最终结果
public class PolandNotation {
public static void main(String[] args) {
//先定义一个逆波兰表达式
//(3+4)×5-6 - × + 3 4 5 6
//4 * 5 - 8 + 60 + 8 / 2 ==> 4 5 * 8 - 60 + 8 2 / +
String suffixExpression="4 5 * 8 - 60 + 8 2 / +";
//思路
//1.先将"3 4 + 5 × 6 – "放入arrayList中
//2.将arrayList传递给一个方法 配合栈，完成计算
List<String> rpnList = getListString(suffixExpression);
System.out.println("rpnList="+rpnList);
int calculate = calculate(rpnList);
System.out.println("结果："+calculate);
}
//将逆波兰表达式，依次将数据和运算符放入arrayList
public static List<String> getListString(String suffixExpression){
String[] split = suffixExpression.split(" ");
ArrayList<String> list = new ArrayList<String>();
for (String ele : split) {
list.add(ele);
}
return list;
}
//逆波兰表达式步骤
public static int calculate(List<String> ls){
//创建栈
Stack<String> stack = new Stack();
//遍历list
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());
}
}
中缀表达式-->后缀表达式
public class PolandNotation2 {
public static void main(String[] args) {
String expression="1+((2+3)*4)-5";
//中缀表达式转成对应放入list
List<String> infixExpressionList= toInfixExpressionList(expression);
//将中缀表达式-->后缀表达式对应的list
List<String> list = parcesSufferExpression(infixExpressionList);
System.out.println(list);
System.out.println("计算结果："+calculate(list));
}
//将中缀表达式-->后缀表达式对应的list
public static List<String> parcesSufferExpression(List<String> ls){
//初始化栈
Stack<String> s1 = new Stack<String>();//符号栈
List<String> s2 = new ArrayList<String>();//中间存放结果的媒介 没有弹出栈 所以list即可
for (String item : ls) {
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栈顶的运算符弹出并加入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较
while (s1.size()!=0&&Operation.getValue(s1.peek())>=Operation.getValue(item)){
s2.add(s1.pop());
}
//需要item压入栈中
s1.push(item);
}
}
//将s1剩余的运算符依次弹出并加入s2
while (s1.size()!=0){
s2.add(s1.pop());
}
return s2;
}
//将中缀表达式转成对应的list
public static List<String> toInfixExpressionList(String s){
//定义一个list 存放中缀表达式对应的内容
List<String> ls = new ArrayList();
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++;//需要后移
}
//如果是数 需要考虑多位数
else {
str="";
while(i<s.length()&&(c=s.charAt(i))>=48&&(c=s.charAt(i))<=57){
str=str+c;//拼接
i++;
}
ls.add(str);
}
}while (i<s.length());
return ls;
}
//将逆波兰表达式，依次将数据和运算符放入arrayList
public static List<String> getListString(String suffixExpression){
String[] split = suffixExpression.split(" ");
ArrayList<String> list = new ArrayList<String>();
for (String ele : split) {
list.add(ele);
}
return list;
}
//逆波兰表达式步骤
public static int calculate(List<String> ls){
//创建栈
Stack<String> stack = new Stack();
//遍历list
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("操作符不存在");
}
return result;
}
}
