前缀表达式
- 前缀表达式又称波兰式,前缀表达式的运算符位于操作符之前
前置表达式的计算机求值:从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对他们做相应的计算(栈顶元素和次顶元素),并将结果存入;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果
中缀表达式
- 中缀表达式就是常见的运算表达式,如(3+4)*5-6
- 中缀表达式的求值使我们最熟悉的,但是对于计算机来说却不好操作,因此在计算过程中,往往会将中缀表达式转为其他表达式来操作(一般转为后缀表达式)
后缀表达式
后缀表达式又称为逆波兰表达式,与前缀表达式相似,只是将运算符位于操作数之后
后缀表达式的计算机求值:从左至扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对他们做相应的计算(次顶元素和栈顶元素),并将结果入栈;重复上述过程直到表达式最右端,最后运算得出值即为表达式的结果
中缀表达式转为后缀表达式
具体步骤如下:
- 初始化两个栈:运算符栈s1和储存中间结果的栈s2;
- 从左至右扫描中缀表达式
- 遇到操作数时,将其压s2
- 遇到运算符的时候,比较其与s1栈顶运算符优先级
- 如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈
- 否则,若优先级比栈顶运算符的高,也将运算符压入s1
- 否则,将s1栈顶的运算符弹出并压入到s2中,再次转到上述粗体步骤与s1中新的栈顶运算符相比较 ;
- 遇到括号时:
- 如果是左括号“(”,则直接压入s1
- 如果是右括号“)”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这对括号丢弃
- 重复上述划线部分,知道表达式的最右端
- 将s1中剩余的运算符依次弹出并压入s2
- 依次弹出s2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式
逆波兰计算器
package com.xxxx.stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolanNotation {
public static void main(String[] args) {
// TODO Auto-generated method stub
//先定义一个逆波兰表达式
//(3+4)*5-6 =>3 4 + 5 * 6 -
//说明为了方便,逆波兰表达式的数字和符号使用空格隔开
/* String str="3 4 + 5 * 6 -";
List<String> rpnlist=getListString(str);
int res=calculate(rpnlist);
System.out.println("计算的结果是"+res);
*/
/*
* 思路:
* 1.先将"3 4 + 5 * 6 -"放到ArrayList中
* 2.将ArrayList传递一个方法,遍历ArrayList配合栈完成计算
* 即"1+((2+3)*4)-5"=>ArrayList[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
* 3.将得到的中缀表达式对应的List=>后缀表达式对应的List
*/
String str="1+((2+3)*4)-5";
List<String> infixString=toInfixString(str);
System.out.println("中缀表达式对应的list"+infixString);
List<String> parseSuffixString=parseSuffixStr(infixString);
System.out.println("后缀表达式对应的list"+parseSuffixString);
System.out.printf("最后的结果是%d",calculate(parseSuffixString));
}
//方法:将中缀表达式转为对应的list
//s="1+((2+3)*4)-5";
public static List<String> toInfixString(String s){
//定义一个List,存放中缀表达式对应的内容
List<String> ls=new ArrayList<String>();
int i=0;//这时是一个指针,用于遍历中缀表达式的字符串
String str;//对多位数的拼接
char c;//每遍历到一个字符,就放到c
do {
//如果是一个非数字,需要加入到ls
if((c=s.charAt(i))<48||(c=s.charAt(i))>57){
ls.add(""+c);
i++;//i需要后移
}else {//如果是一个数,需要考虑多位数
str="";//先将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=>后缀表达式对应的List
public static List<String> parseSuffixStr(List<String> ls){
//定义两个栈
Stack<String> s1=new Stack<String>();//符号栈
//说明:因为s2这个栈,在整个转换的过程中,没有pop操作,而且我们后面还需要逆序输出
//因此比较麻烦,这里我们就不用Stack<String>了,直接使用List<String>了
// Stack<String> s2=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栈顶运算符,将s1栈顶的运算符弹出并压入到s2中,再次转到上述粗体步骤与s1中新的栈顶运算符相比较
while(s1.size()!=0&&priority(item)<=priority(s1.peek())) {
s2.add(s1.pop());
}
s1.push(item);
}
}
//将s1中的剩余的运算符依次弹出并加入s2
while(s1.size()!=0) {
s2.add(s1.pop());
}
return s2;//注意因为是存放到List,因此按顺序输出就是对应的后缀表达式
}
//定义一个判断优先级的方法
public static int priority(String s) {
if(s.equals("*")||s.equals("/")) {
return 1;
}else if(s.equals("+")||s.equals("-")) {
return 0;
}else {
return -1;//假定目前的表达式只有+、-、*、/
}
}
//将一个逆波兰表达式,依次将数据和运算符放入ArrayList中
public static List<String> getListString(String str){
//将str分割
String[] split=str.split(" ");
List<String> list=new ArrayList<String>();
for(String el:split) {
list.add(el);
}
return list;
}
//完成对逆波兰的运算
public static int calculate(List<String> ls) {
//创建给栈,只需要一个栈
Stack<String> stack=new Stack<String>();
//遍历ls
for(String item:ls) {
//这里使用正则表达式取出数
if(item.matches("\\d+")) {//匹配的是多位数
//入栈
stack.push(item);
}else {
//pop出两个数,并运算,再入栈
int num1=Integer.parseInt(stack.pop());
int num2=Integer.parseInt(stack.pop());
int res=0;
if(item.equals("+")) {
res=num1+num2;
}else if(item.equals("-")) {
res=num2-num1;
}else if(item.equals("*")) {
res=num1*num2;
}else if(item.equals("/")) {
res=num2/num1;
}else {
throw new RuntimeException("运算符有误");
}
//把res入栈
stack.push(res+"");
}
}
//最后留在栈中的数据是运算结果
return Integer.parseInt(stack.pop());
}
}