中缀转后缀表达式（逆波兰式java）

中缀表达式转后缀表达式

一、介绍：

中缀表达式：操作符是以中缀形式处于操作数的中间（例：3 + 4）
后缀表达式：也称为逆波兰式，方便计算机执行运算

二、中缀转后缀思路：

1. 创建两个栈，一个存储运算符s1，一个存储中间结果的栈s2
2. 从左向右扫描表达式
3. 如果遇见数值（操作数）压缩s2
4. 如果扫描到运算符，于s1栈顶比较优先级
   1）如果s1为空，或栈顶的运算符为“（”直接压入栈
   2）如果s1栈顶的优先级比扫描到的小，运算符同样压入栈
   3）如果s1栈顶的优先级比扫描到的运算符大，弹出s1栈顶元素并入栈s2，将扫描的值依次从头开始判断。
5. 遇见括号
   1）如果为“（”，直接入栈s1
   2）如果为“）”右括号，依次弹出s1栈顶的运算符，并压入s2，直至遇到左括号为止，并将这一对括号丢弃
6. 重复步骤2到5，直至中缀表达式的最右端
7. 如果栈s1还有运算符，依次弹出并压入s2
8. 从s2中输出的表达式并非为最终的结果，应该为将其逆序输出便是由中缀表达式转后缀表达式。

三、计算后缀表达式思路：

1. 将后缀字符串转为List集合,并设置index，遍历时进行定位
2. 创建栈，对字符串中扫描出的字符进行判断

1. 如果为数据，直接入栈
2. 如果为运算符，在栈中弹出两个数值，进行计算，并将运算后的结果入栈

3. 重复上述步骤，最终将字符串遍历完，留在栈中的为最终结果

三、代码演示：

package 栈;

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

public class 中缀表达式转后缀表达式 {

	public static void main(String[] args) {
		String expression = "1+(2+3)*4-5";		//中缀表达式
		List<String> infixExpression = toInfixExpressionList(expression);
		System.out.println("中缀表达式对应的List:"+infixExpression);		//中缀表达式对应的List:[1, +, (, 2, +, 3, ), *, 4, -, 5]
		List<String> suffixExpressionList = parseSuffixExpressionList(infixExpression);
		System.out.println("后缀表达式对应的List：" + suffixExpressionList);		//[1, 2, 3, +, 4, *, +, 5, -]
		System.out.println(calculate(suffixExpressionList));
	}
	
	//将中缀表达式字符串语句转换为List
	public static List<String> toInfixExpressionList(String s){
		List<String> list = new ArrayList<String>();		//用于存放中缀表达式
		int i = 0;
		String str = ""; 	//对于多位数的数值进行拼接
		char c;			//遍历时提取的字符
		do {
			c = s.charAt(i);
			if(c<48||c>57) {		//0和9对应的ASCII值分别为48和57,如果判断非数值则执行
				list.add(""+c);		//将c转为字符串形式并存储到list中
				i++;
			}else {
				str = "";
				//在循环体中往后查找多位数时并拼接数值
				while(i<s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
					str += c;
					i++;
				}
				list.add(str);
			}
		}while(i<s.length());
		return list;
	}
	
	//将中缀表达式转后缀
	public static List<String> parseSuffixExpressionList(List<String> list){
		Stack<String> s1 = new Stack<String>();
		List<String> s2 = new ArrayList<String>();
		for(String item:list) {
			if(item.matches("\\d+")) {
				s2.add(item);
			}else if(item.equals("(")) {
				s1.push(item);
			}else if(item.equals(")")) {
				while(!s1.peek().equals("(")) {
					s2.add(s1.pop());
				}
				s1.pop();
			}else {
				if(s1.size()!=0 && !item.equals("(") && Operation.getValue(s1.peek())>= Operation.getValue(item)){
					s2.add(s1.pop());
				}
				s1.push(item);
			}
		}
		while(s1.size() != 0) {
			s2.add(s1.pop());
		}
		return s2;
	}
	
		
	//完成逆波兰表达式的计算
	public static int calculate(List<String> ls) {
		//使用系统自带的栈功能
		Stack<String> stack = new Stack<String>();
		//遍历ls，并通过压栈push 和 出栈pop进行计算
		for(String item : ls) {
			if(item.matches("\\d+")) {		//使用正则表达式
				stack.push(item);			//如果为数值，入栈
			}else {
				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 = num1/num2;
				}else {
					throw new RuntimeException("运算符有误");
				}
				stack.push(""+res); 	//入栈
			}
		}
		
		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 result = 0;
		switch(operation) {
		case "+":
			result = ADD;
			break;
		case "-":
			result = SUB;
			break;
		case "*":
			result = MUL;
			break;
		case "/":
			result = DIV;
			break;
		default:
			break;
		}
		return result;
	}
}

如有错误，愿不吝指教！！！