前缀、中缀、后缀表达式以及逆波兰计算器

前缀、中缀、后缀表达式

前缀表达式波兰表达式

前缀表达式的运算符位于操作数之前

就比如（3+4）x5-6对应的前缀表达式就是 - X + 3 4 5 6

前缀表达式在计算机中的计算机求值

从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(栈项元素和次项元素)，并将结果入栈;重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果

例如: (3+4)X5-6对应的前缀表达式就是一 X +3456针对前缀表达式求值步骤如下:
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，由此得出最终结果

中缀表达式

1)中缀表达式就是常见的运算表达式，如(3+4)X5-6
2) 中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作(前面我们讲的案例
就能看的这个问题)，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式)

需要考虑运算符的优先级谁高谁低，我们人为容易理解，但是我们的计算机不容易

后缀表达式逆波兰表达式

1)后缀表达式又称逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后
2)中举例说明: (3+4)X5-6 对应的后缀表达式就是3 4 + 5 X 6 -

3)再比如:

正常表达式	逆波兰表达式
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)X5-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，由此得出最终结果

逆波兰计算器

1)输入一个逆波兰表达式使用栈(Stack), 计算其结果
2)支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简
化，只支持对整数的计算。

思路

1.先将逆波兰表达式放到一个ArrayList中

2.将ArrayList传给一个方法，这个方法配合我们的栈完成计算

public class PolandNotation {public static void main(String[] args) {//先定义一个逆波兰表达式//（3+4）*5-6 ===》 3  4  +  5  *  6  -//为了方便，逆波兰表达式数字和符号用空格隔开String suffixExpression = "3 4 + 5 * 6 -";List<String> rpnList = getListString(suffixExpression);System.out.println(rpnList);}//将逆波兰表达式，依次将数据和运算符放入到ArrayList中public static List<String> getListString(String suffixExpression){//分割逆波兰表达式String[] split = suffixExpression.split(" ");List<String> list = new ArrayList<>();for (String ele : split) {list.add(ele);}return list;}
}

计算代码

package com.wang.stack;import java.util.ArrayList;
import java.util.List;
import java.util.Stack;/*** @author 王庆华* @version 1.0* @date 2020/12/19 16:51* @Description TODO* @pojectname 算法代码*/
public class PolandNotation {public static void main(String[] args) {//先定义一个逆波兰表达式//（3+4）*5-6 ===》 3  4  +  5  *  6  -//为了方便，逆波兰表达式数字和符号用空格隔开String suffixExpression = "30 4 + 5 * 6 -";List<String> rpnList = getListString(suffixExpression);System.out.println(rpnList);int res = calculate(rpnList);System.out.println("计算结果是"+res);}//将逆波兰表达式，依次将数据和运算符放入到ArrayList中public static List<String> getListString(String suffixExpression){//分割逆波兰表达式String[] split = suffixExpression.split(" ");List<String> list = new ArrayList<>();for (String ele : split) {list.add(ele);}return list;}//将逆波兰表达式计算public static int calculate(List<String> ls){//创建一个栈 只需一个栈即可Stack<String> stack = new Stack<>();//遍历lsfor (String item : ls) {//这里使用正则表达式取出数字if (item.matches("\\d+")){//匹配多位数//入栈stack.push(item);}else{//不是数字  pop出两个数并进行运算，在入栈//考虑顺序，先出来的是num2int 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("运算符有误");}//把res入栈stack.push(res+"");}}//最后留在stack中的数据就是运算结果return Integer.parseInt(stack.pop());}
}

那上面是我们自己写出来了逆波兰（后缀）表达式，那如果我们给一个中缀表达式，怎么让程序自己转换成逆波兰表达式并进行计算呢？

中缀表达式转换成后缀表达式

具体步骤如下:

初始化两个栈: 运算符栈s1和储存中间结果的栈s2;
从左至右扫描中缀表达式;
遇到操作数时，将其压s2;
遇到运算符时，比较其与s1栈项运算符的优先级:
(1)如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈;
(2)否则，若优先级比栈项运算符的高，也将运算符压入s1;
(3)否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较; .
遇到括号时:
(1)如果是左括号“(”，则直接压入s1
(2)如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
重复步骤2至5，直到表达式的最右边
将s1中剩余的运算符依次弹出并压入s2
依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

举例

中缀表达式：1+((2+3)*4)-5

扫描到的元素	s2（栈底->栈顶）	s1（栈底->栈顶）	说明
1	1	空	数字直接入栈
+	1	+	s1为空，符号直接入栈
(	1	+（	左括号，直接入栈
)	1	+（（	同上
2	1 2	+（（	数字入栈
+	1 2	+（（+	s1栈顶为左括号，运算符直接入栈
3	1 2 3	+（（+	数字入栈
)	1 2 3 +	+（	右括号，弹出运算符直到遇到左括号
*	1 2 3 +	+（*	s1栈顶为左括号，运算符直接入栈
4	1 2 3 + 4	+（*	数字直接入栈
)	1 2 3 + 4 *	+	右括号，弹出运算符直到遇到左括号
—	1 2 3 + 4 * +	—	—与+运算符同级，先弹出+，再压入-
5	1 2 3 + 4 * + 5	—	数字入栈
达到最右端	1 2 3 + 4 * + 5 -	空	s1中剩余运算符出栈运算

代码

1.将字符串表达式转换成对应的List

/**//将中缀表达式转换成对应的List* @param s 传入的字符串表达式* @return*/
public static List<String> toInfixExpressionList(String s){//定义List，存放中缀表达式对应的内容List<String> ls = new ArrayList<>();int i = 0; //定义我们的index来辅助我们遍历我们的中缀表达式字符串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 = "";//先将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;
}

2.将中缀表达式的List转换成后缀表达式的List

/**//将中缀表达式的List转换成后缀表达式的List//【1,+，(，,(,2,+,3，),*,4，),-，5】===>[1,2,3,+,4,*,+,5,-]* @param ls    我们中缀表达式对应的List* @return*/
public static List<String> parseSuffixExpressionList(List<String> ls){//定义两个栈Stack<String> s1 = new Stack<String>();//符号栈//存储结果的栈,因为这个栈整个过程中没有pop的过程，且//最后我们还得逆序输出它，所以我们用List s2 来代替它//Stack<String> s2 = new Stack<>();List<String> s2 = new ArrayList<String>();//遍历lsfor (String item : ls) {//如果是数字，入s2if (item.matches("\\d+")){s2.add(item);}else if (item.equals("(")){//直接入s1符号栈s1.push(item);}else if (item.equals(")")){while (!s1.peek().equals("(")){//去找我们的(s2.add(s1.pop());}s1.pop();//消掉一对小括号}else{//优先级问题//当s1栈顶的运算符优先级》=item的运算符优先级//缺少判断优先级大小的方法while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)){s2.add(s1.pop());}//把当前的运算符压入s1符号栈s1.push(item);}}//将s1剩余的运算符加入到s2中while (s1.size() != 0){s2.add(s1.pop());}return  s2;//因为存放到的是List，正常输出就是我们的后缀表达式的List}

结合我们上个例子的计算代码，就能直接计算我们的中缀表达式了

中缀表达式====>后缀表达式====>计算结果

package com.wang.stack;import sun.security.timestamp.TSRequest;import java.util.ArrayList;
import java.util.List;
import java.util.Stack;/*** @author 王庆华* @version 1.0* @date 2020/12/19 16:51* @Description TODO* @pojectname 算法代码*/
public class PolandNotation {public static void main(String[] args) {//完成一个中缀表达式转成后缀表达式的功能//直接对字符串遍历不方便，因此先将表达式转换成一个中缀表达式对应的List//1+((2+3)*4)-5 - ==> 【1,+，(，,(,2,+,3，),*,4，),-，5】String expression = "1+((2+3)*4)-5";List<String> toInfixExpressionList = toInfixExpressionList(expression);System.out.println(toInfixExpressionList);List<String> parseSuffixExpressionList = parseSuffixExpressionList(toInfixExpressionList);System.out.println("后缀表达式的List结果为"+parseSuffixExpressionList);int result = calculate(parseSuffixExpressionList);System.out.println("计算结果为"+result);}/**//将中缀表达式转换成对应的List* @param s 传入的字符串表达式* @return*/public static List<String> toInfixExpressionList(String s){//定义List，存放中缀表达式对应的内容List<String> ls = new ArrayList<>();int i = 0; //定义我们的index来辅助我们遍历我们的中缀表达式字符串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 = "";//先将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//【1,+，(，,(,2,+,3，),*,4，),-，5】===>[1,2,3,+,4,*,+,5,-]* @param ls    我们中缀表达式对应的List* @return*/public static List<String> parseSuffixExpressionList(List<String> ls){//定义两个栈Stack<String> s1 = new Stack<String>();//符号栈//存储结果的栈,因为这个栈整个过程中没有pop的过程，且//最后我们还得逆序输出它，所以我们用List s2 来代替它//Stack<String> s2 = new Stack<>();List<String> s2 = new ArrayList<String>();//遍历lsfor (String item : ls) {//如果是数字，入s2if (item.matches("\\d+")){s2.add(item);}else if (item.equals("(")){//直接入s1符号栈s1.push(item);}else if (item.equals(")")){while (!s1.peek().equals("(")){//去找我们的(s2.add(s1.pop());}s1.pop();//消掉一对小括号}else{//优先级问题//当s1栈顶的运算符优先级》=item的运算符优先级//缺少判断优先级大小的方法while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)){s2.add(s1.pop());}//把当前的运算符压入s1符号栈s1.push(item);}}//将s1剩余的运算符加入到s2中while (s1.size() != 0){s2.add(s1.pop());}return  s2;//因为存放到的是List，正常输出就是我们的后缀表达式的List}//将逆波兰表达式，依次将数据和运算符放入到ArrayList中public static List<String> getListString(String suffixExpression){//分割逆波兰表达式String[] split = suffixExpression.split(" ");List<String> list = new ArrayList<>();for (String ele : split) {list.add(ele);}return list;}//将逆波兰表达式计算public static int calculate(List<String> ls){//创建一个栈 只需一个栈即可Stack<String> stack = new Stack<>();//遍历lsfor (String item : ls) {//这里使用正则表达式取出数字if (item.matches("\\d+")){//匹配多位数//入栈stack.push(item);}else{//不是数字  pop出两个数并进行运算，在入栈//考虑顺序，先出来的是num2int 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("运算符有误");}//把res入栈stack.push(res+"");}}//最后留在stack中的数据就是运算结果return Integer.parseInt(stack.pop());}
}
//编写一个类Operation，可以返回一个运算符对应的优先级
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 res = 0;switch (operation){case "+":{res = ADD;break;}case "-":{res = SUB;break;}case "*":{res = MUL;break;}case "/":{res = DIV;break;}default: {System.out.println("不存在该运算符");break;}}return res;}
}

那么问题来了，我们可以完成这些但是小数并不支持，那怎么支持小数也能进行计算呢？

我们还需兼容处理,过滤任何空白字符，包括空格、制表符、换页符

完整版逆波兰计算器

package com.wang.stack;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;/****/
public class ReversePolishMultiCalc {/*** 匹配 + - * / ( ) 运算符*/static final String SYMBOL = "\\+|-|\\*|/|\\(|\\)";static final String LEFT = "(";static final String RIGHT = ")";static final String ADD = "+";static final String MINUS= "-";static final String TIMES = "*";static final String DIVISION = "/";/*** 加減 + -*/static final int LEVEL_01 = 1;/*** 乘除 * /*/static final int LEVEL_02 = 2;/*** 括号*/static final int LEVEL_HIGH = Integer.MAX_VALUE;static Stack<String> stack = new Stack< String>();static List<String> data = Collections.synchronizedList(new ArrayList<String>());/*** 去除所有空白符* @param s* @return*/public static String replaceAllBlank(String s ){// \\s+ 匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]return s.replaceAll("\\s+","");}/*** 判断是不是数字 int double long float* @param s* @return*/public static boolean isNumber(String s){Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");return pattern.matcher(s).matches();}/*** 判断是不是运算符* @param s* @return*/public static boolean isSymbol(String s){return s.matches(SYMBOL);}/*** 匹配运算等级* @param s* @return*/public static int calcLevel(String s){if("+".equals(s) || "-".equals(s)){return LEVEL_01;} else if("*".equals(s) || "/".equals(s)){return LEVEL_02;}return LEVEL_HIGH;}/*** 匹配* @param s* @throws Exception*/public static List<String> doMatch (String s) throws Exception{if(s == null || "".equals(s.trim())) throw new RuntimeException("data is empty");if(!isNumber(s.charAt(0)+"")) throw new RuntimeException("data illeagle,start not with a number");s = replaceAllBlank(s);String each;int start = 0;for (int i = 0; i < s.length(); i++) {if(isSymbol(s.charAt(i)+"")){each = s.charAt(i)+"";//栈为空，(操作符，或者 操作符优先级大于栈顶优先级 && 操作符优先级不是( )的优先级 及是 ) 不能直接入栈if(stack.isEmpty() || LEFT.equals(each)|| ((calcLevel(each) > calcLevel(stack.peek())) && calcLevel(each) < LEVEL_HIGH)){stack.push(each);}else if( !stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())){//栈非空，操作符优先级小于等于栈顶优先级时出栈入列，直到栈为空，或者遇到了(，最后操作符入栈while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek()) ){if(calcLevel(stack.peek()) == LEVEL_HIGH){break;}data.add(stack.pop());}stack.push(each);}else if(RIGHT.equals(each)){// ) 操作符，依次出栈入列直到空栈或者遇到了第一个)操作符，此时)出栈while (!stack.isEmpty() && LEVEL_HIGH >= calcLevel(stack.peek())){if(LEVEL_HIGH == calcLevel(stack.peek())){stack.pop();break;}data.add(stack.pop());}}start = i ;    //前一个运算符的位置}else if( i == s.length()-1 || isSymbol(s.charAt(i+1)+"") ){each = start == 0 ? s.substring(start,i+1) : s.substring(start+1,i+1);if(isNumber(each)) {data.add(each);continue;}throw new RuntimeException("data not match number");}}//如果栈里还有元素，此时元素需要依次出栈入列，可以想象栈里剩下栈顶为/，栈底为+，应该依次出栈入列，可以直接翻转整个stack 添加到队列Collections.reverse(stack);data.addAll(new ArrayList<String>(stack));System.out.println(data);return data;}/*** 算出结果* @param list* @return*/public static Double doCalc(List<String> list){Double d = 0d;if(list == null || list.isEmpty()){return null;}if (list.size() == 1){System.out.println(list);d = Double.valueOf(list.get(0));return d;}ArrayList<String> list1 = new ArrayList<String>();for (int i = 0; i < list.size(); i++) {list1.add(list.get(i));if(isSymbol(list.get(i))){Double d1 = doTheMath(list.get(i - 2), list.get(i - 1), list.get(i));list1.remove(i);list1.remove(i-1);list1.set(i-2,d1+"");list1.addAll(list.subList(i+1,list.size()));break;}}doCalc(list1);return d;}/*** 运算* @param s1* @param s2* @param symbol* @return*/public static Double doTheMath(String s1,String s2,String symbol){Double result ;switch (symbol){case ADD : result = Double.valueOf(s1) + Double.valueOf(s2); break;case MINUS : result = Double.valueOf(s1) - Double.valueOf(s2); break;case TIMES : result = Double.valueOf(s1) * Double.valueOf(s2); break;case DIVISION : result = Double.valueOf(s1) / Double.valueOf(s2); break;default : result = null;}return result;}public static void main(String[] args) {//String math = "9+(3-1)*3+10/2";String math = "12.8 + (2 - 3.55)*4+10/5.0";try {doCalc(doMatch(math));} catch (Exception e) {e.printStackTrace();}}
}

前缀、中缀、后缀表达式以及逆波兰计算器相关推荐

java中缀表达式转后缀表达式（逆波兰算法）
四则运算是栈的重要应用之一中缀表达式转后缀表达式(逆波兰算法)过程从左到右遍历中缀表达式数字直接输出为后缀表达式一部分如果是符号,则判断与栈顶元素的优先级高于栈顶元素优先级直接入栈低于或等 ...
C语言栈的运用：后缀表达式（逆波兰表达式）计算器
原理很简单,当操作者输入中每遇数字便将数字压入数栈,每遇符号便进行两次弹栈进行该符号的运算,运算结果再次压入数栈.唯一要注意的一点就是进行除法运算时需要判断除数是否为0. 头文件: /*Captain ...
前缀中缀后缀表达式的计算求值
原文在这里表达式前缀表达式(波兰表达式) 前缀表达式又称波兰式,前缀表达式的运算符位于操作数之前举例说明: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 前缀表达式求值 ...
前缀中缀后缀表达式介绍
一前缀表达式 1 前缀表达式又称波兰式,前缀表达式的运算符位于操作数之前. 2 举例 (3+4)×5-6 对应的前缀表达式是: - × + 3 4 5 6 3 前缀表达式的计算机求值过程从右至左扫 ...
数据结构:前缀,中缀,后缀表达式(逆波兰表达式)
前缀表达式(波兰表达式) 前缀表达式的运算符位于操作数之前. 比如 (1+2)*3-4 对应的前缀表达式就是: - * + 1 2 3 4 前缀表达式的计算机求值从右至左扫描表达式,遇到数字时,就 ...
逆波兰式 java_逆波兰式（后缀表达式）的计算中缀表达式转后缀表达式（逆波兰式）【java实现】...
一.逆波兰式(后缀表达式)计算思路: * 1.遍历逆波兰式的集合 * 2.当遍历的元素为数字时,入栈 stack * 3.当遍历的元素为运算符时,stack栈弹出两个数,num2 num1,并用该运 ...
中缀转后缀表达式、逆波兰表达式、leetcode224、227
中缀转后缀表达式python leetcode224.227 class Solution:def calculate(self, s): # 中缀转后缀def evalRPN(tokens):sta ...
【算法】逆波兰式（后缀表达式）的计算中缀表达式转后缀表达式（逆波兰式）
本文为博主九师兄(QQ:541711153 欢迎来探讨技术)原创文章,未经允许博主不允许转载. 文章目录 1.概述 2.简化版 M.扩展阅读 1.概述地址:https://www.bilibili. ...
前缀中缀后缀表达式2
对于未经训练的用户来说,计算机科学领域中数学表达式求值的传统方法即不顺手又难以使用:软件工程师 Nikola.Stepan 旨在改变这些传统方法.他的 applet W3Eval 对表达式求值与您用纸 ...
python【数据结构与算法】表达式(前缀中缀后缀表达式)与Two fork tree
文章目录 1 相关概念 2 与二叉树关系 3 表达式转换 4 另一种方法 1 相关概念前缀表达式(Prefix Notation)是指将运算符写在前面操作数写在后面的不包含括号的表达式,而且为了纪念 ...

前缀、中缀、后缀表达式以及逆波兰计算器

前缀、中缀、后缀表达式

前缀、中缀、后缀表达式以及逆波兰计算器相关推荐

最新文章

热门文章