栈---中缀表达式转后缀表达式并完成表达式的计算

前缀表达式(波兰表达式)，从右向左扫描表达式。前缀表达式的运算符位于操作数之前。
中缀表达式，也就是常见的表达式，但是计算机不容易识别。
后缀表达式(逆波兰表达式)，从左向右扫描表达式。

使用栈完成对表达式的计算：
思路：
1.先将表达式转为相对应的链表list
2.完成对运算符优先级的定义
3.根基优先级将该链表转为逆波兰表达式相对应的链表list
4.根据逆波兰表达式对应的list进行计算得出结果

Java代码实现：

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

@SuppressWarnings("all")
public class PolandNotation {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	
	//完成将中缀表达式转为后缀表达式的功能
	
	String expression = "1+((2+3)*4)-5";
	//先将表达式转为对应的list
	List<String> infixExpressionList = toInfixExpressionList(expression);
	System.out.println("中缀表达式转为对应的list："+infixExpressionList);
	//将得到的中缀表达式对应的list转为后缀表达式对应的list
	List<String> parseSuffixExpressionList = parseSuffixExpressionList(infixExpressionList);
	//应该是1,2,3,+,4,*,+,5,-
	System.out.println("后缀表达式对应的list："+parseSuffixExpressionList);
	//计算该后缀表达式的结果
	System.out.println("计算结果为："+cal(parseSuffixExpressionList));
	
	//先定义逆波兰表达式
	//(3 + 4) * 5 - 6 =>3 4 + 5 * 6 -
	String suffixExpression = "3 4 + 5 * 6 -";
	//直接计算逆波兰表达式思路：
	/**
	 * 1.先将"3 4 + 5 * 6 -"放到ArrayList中
	 * 2.将ArrayList传递给一个方法，遍历ArrayList配合栈完成计算
	 */
	
	List<String> list = getListString(suffixExpression);
	System.out.println("List="+list);
	
	int res = cal(list);
	System.out.println("计算的结果是："+res);
	
}

//将中缀表达式转换为后缀表达式
/**
 * 思路：
 * 一.先将中缀表达式转为对应的list
 * 二.将list转为后缀表达式对应的list
 * 
 */

//一.先将中缀表达式转为对应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 = "";//先将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> parseSuffixExpressionList(List<String> ls){
	//初始化栈，定义俩个栈
	Stack<String> s1 = new Stack();//符号栈
	//因为s2栈在整个转换过程没有pop操作，而且后续需要逆序输出，所以直接使用list
	List<String> s2 = new ArrayList();
	
	//遍历ls
	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();
		}else {
			//！！！！考虑优先级
			//当item的运算符的优先级<= s1栈顶运算符的优先级，
			//则将s1栈顶的运算符弹出，并加入到s2,再次与s1栈顶运算符比较，直到大于或者栈为空
			//需要一个比较优先级高低的方法
			while(s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
				s2.add(s1.pop());
			}
			//将当前运算符item压入栈中
			s1.push(item);
		}
	}
	
	//扫描完毕后，将s1中剩余的运算符弹出并加入s2
	s2.add(s1.pop());
	//存放的s2是一个list链表，所以不需要再逆序
	return s2;
}
	

//将一个逆波兰表达式，依次将数据和运算符放入到ArrayList中
public static List<String> getListString(String suffixExpression){
	//将suffixExpression 分割
	String[] split = suffixExpression.split(" ");
	List<String> list = new ArrayList<>();
	for(String ele : split) {
		list.add(ele);
	}
	return list;
}

//完成对逆波兰表达式的计算
public static int cal(List<String> ls) {
	//创建栈，一需要一个栈
	Stack<String> stack = new Stack<>();
	//遍历ls
	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("运算符有误");
			}
			//把res入栈
			stack.push(""+res);
		}
	}
	//最后留在栈里的数据就是运算结果
	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 :
		break;
	}
	return result;
}
}