中缀表达式转后缀表达式

1.后缀表达式介绍

(1) 后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后

(2) 中举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 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 + =

2  计算后缀表达式求的算式的值 

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

例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:

1)从左至右扫描，将3和4压入堆栈；

2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；

3)将5入栈；

4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；

5)将6入栈；

6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果 

 代码实现

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class InversePoland {

	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 suffix="3 4 + 5 * 6 -";
		String suffix2="4 5 * 8 - 60 + 8 2 / +";
		List<String> list=getListString(suffix2);
		System.out.println(list);
		
		int res=calculate(list);
		System.out.println("计算结果是="+res);
	}
	
	public static List<String> getListString(String exp){
		String str[]=exp.split(" ");
		List<String> list=new ArrayList<>();
		for(String ele:str) {
			list.add(ele);
		}
		return list;
	}
	
	public static int calculate(List<String> list) {
		Stack<String> stack=new Stack<>();
		for(String item:list) {
			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());
	}
}

运行结果：

 3. 中缀表达式转后缀表达式

 

具体步骤如下:

1)初始化两个栈：运算符栈s1和储存中间结果的栈s2；

2)从左至右扫描中缀表达式；

3)遇到操作数时，将其压s2；

4)遇到运算符时，比较其与s1栈顶运算符的优先级：

4).(1)如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；

4).(2)否则，若优先级比栈顶运算符的高，也将运算符压入s1；

否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；

即，直到栈顶没有操作符

代码实现

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class NifixToSuffix {

	public static void main(String[] args) {
		//完成一个中缀表达式转后缀表达式的功能
//									[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
//									
//		1. 1+((2+3)*4-5 ==>  ArrayList [1,+,(,(,2,+,3,),*,4,-,5] 
		String exp="1+((2+3)*4)-5";
		List <String> ls=toInfixList(exp);
		System.out.println("前缀表达式：");
		System.out.println(ls);
		
//		ArrayList [1,+,(,(,2,+,3,),*,4,-,5]==> ArrayList[1,2,3,+,4,*,+,5,-]
		
		List<String> sulist=parseSuffix(ls);
		//答案： [1,2,3,+,4,*,+,5,-]
//				[1, 2, 3, +, 4, *, +, 5, -]
		System.out.println("转为后缀表达式结果：");
		System.out.println(sulist);
		
		int result=InversePoland.calculate(sulist);
		System.out.println("计算结果：");
		System.out.println(result);
	}
	
	public static List<String> parseSuffix(List<String> ls){
		Stack<String> s1=new Stack<String> (); //符号栈
		//说明：因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出，
		//因此比较麻烦，所以用List<>;
		List<String> s2=new ArrayList<>();  //储存中间结果的栈
		for(String item:ls) {
			//如果是一个数就加入s2
			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(); // !!!将（ 弹出s1栈，消除小括号
			}else {
				//当item的优先级小于等于s1栈顶运算符，将s1栈顶的运算符弹出并加入到s2中，
				//直到栈顶没有运算符
				while(s1.size()!=0&&getRank(s1.peek()) >= getRank(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> toInfixList(String s){
//		List 存放中缀表达式对应的内容
		List<String> ls=new ArrayList<>();
		
		String str = "";
		char c; //每遍历一个字符，就放入到c
		for(int i=0;i<s.length();i++) {
			c=s.charAt(i);
			if((c>='0')&&(c<='9')) {
				str+=""+c;
			}else {
//				System.out.println(str.length());
				if(str.length()!=0) {
					ls.add(str);
					str="";
				}
				ls.add(""+c);
			}
		}
		if(str.length()!=0) ls.add(str);
		
		return ls;
	}
	
	//获取优先级
	public static int getRank(String oper) {
		int result=0;
		switch (oper) {
		case "+":
			result=1;
			break;
		case "-":
			result=1;
			break;
		case "*":
			result=2;
			break;
		case "/":
			result=2;
			break;
		default:
//			System.out.println("不存在该运算符(");
			break;
		}
		return result;
	}
	
}

运算结果：