数据结构与算法-逆波兰表达式(后缀表达式)

前缀、中缀、后缀表达式

1. 前缀表达式（波兰表达式）
   前缀表达式又称波兰表达式，前缀表达式的运算符位于操作数之前
   例如(3+4)*5-6对应的前缀表达式就是- * + 3 4 5 6
2. 中缀表达式
   中缀表达式就是常见的运算表达式，如(3+4)*5-6
   中缀表达式的求值是我们人最熟悉的，但是他对计算机来说却不好操作，因此，在计算结果时，往往会将中缀表达式转换成其他表达式来操作（一般转换成后缀表达式）
3. 后缀表达式（逆波兰表达式）
   后缀表达式又称为逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后
   (3+4)*5-6对应的后缀表达式就是 3 4 + 5 * 6 -

应用场景

• 实现计算器功能

整体思路

• 获取将要计算的中缀表达式
• 将中缀表达式转换为后缀表达式

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

• 后缀表达式的计算机求值

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

例如(3+4)5-6对应的后缀表达式就是 3 4 + 5 * 6 -，针对后缀表达式求值步骤如下：
1)从左至右扫描，将3和4压入堆栈；
2)遇到+运算符，因此弹出3和4（3为次顶元素，4位栈顶元素），计算3和4的值，得7，再将7入栈；
3)将5入栈；
4)接下来是运算符，因此弹出5和7，计算出7*5=35，将35入栈；
5)将6入栈；
6)最后的运算符是-，计算出35-6=29，由此得出最终结果；

代码实现

public class PolandNotation {

	public static void main(String[] args) {
		
		//完成一个将中缀表达式转换为后缀表达式的功能
		//说明
		//1.(11+4)*5-6 -> 11 4 + 5 * 6 -
		//2.因为直接对一个字符串进行操作，不方便，先将这个字符串转成一个中缀的list
		String expression = "(11+4)*5-6";
		List<String> infixExpressionList = PolandNotation.toInfixExpressionList(expression);
		System.out.println(infixExpressionList);
		//3.将得到的中缀表达式对应的list -> 转换成后缀表达式对应的list
		//即 [(, 11, +, 4, ), *, 5, -, 6] -> [11, 4, +, 5, * ,6 , -]
		List<String> parseSuffixExpressionList = PolandNotation.parseSuffixExpressionList(infixExpressionList);
		System.out.println(parseSuffixExpressionList);
		
		
		//先定义一个逆波兰表达式
		//(11+4)*5-6 对应的后缀表达式是 11 4 + 5 * 6 -
		//String suffixExpression = "11 4 + 5 * 6 -";
		//1.先将suffixExpression放到一个ArrayList中
		//2.将ArrayList传给一个方法，遍历ArrayList配合栈完成计算
		//List<String> rpnList = PolandNotation.getListString(suffixExpression);
		int result = calculate(parseSuffixExpressionList);
		System.out.println("最终结果: " + result);
	}
	
	
	//将中缀表达式转换成后缀表达式
	public static List<String> toInfixExpressionList(String expression) {
		//定义一个list存放中缀表达式对应内容
		List<String> list = new ArrayList<>();
		
		int i = 0;  //这是一个指针，用于遍历中缀表达式字符串
		String str;  //对多位数的拼接
		char c;  //每遍历到一个字符，就放入到c中
		do {
			//如果c是一个非数字，就需要加入到list中
			if ((c=expression.charAt(i)) < 48 || (c=expression.charAt(i)) > 57) {
				list.add("" + c);
				i++;
			} else {  //如果是数，需要考虑多位数的问题
				str = ""; //先将str置空
				while (i < expression.length() && ((c=expression.charAt(i)) >= 48) && (c=expression.charAt(i)) <= 57) {
					str += c;
					i++;
				}
				list.add(str);
			}
		} while (i < expression.length());
		
		return list;
	}
	
	/**
	 * 将得到的中缀表达式对应的list -> 转换成后缀表达式对应的list
	 */
	public static List<String> parseSuffixExpressionList(List<String> ls) {
		//定义两个栈
		Stack<String> s1 = new Stack<>();  //符号栈
		//Stack<String> s2 = 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栈顶的运算符弹出并加入到s2中，再次转到(4-1)与s1中的新的栈顶运算符相比较
				while (s1.size() > 0 && Operation.getValue(item) <= Operation.getValue(s1.peek())) {
					//如果循环peek的值为"("，不存在该运算符，返回值为0，item的优先级必定大于0，循环终止
					s2.add(s1.pop());
				}
				s1.push(item);
			}
		}
		
		//将s1中剩余的元素加入到s2
		while (s1.size() > 0) {
			s2.add(s1.pop());
		}
		
		return s2;
	}
	
	//将一个逆波兰表达式依次将数据和运算符放入ArrayList中
	public static List<String> getListString(String suffixExpression) {
		//将suffixExpression分割
		String[] arr = suffixExpression.split(" ");
		List<String> list = new ArrayList<>();
		for (String ele : arr) {
			list.add(ele);
		}
		
		return list;
	}
	
	/**
	 * 完成对逆波兰表达式的运算
	 * 
	 * 1)从左至右扫描，将3和4压入堆栈；
	 * 2)遇到+运算符，因此弹出3和4（3为次顶元素，4位栈顶元素），计算3和4的值，得7，再将7入栈；
	 * 3)将5入栈；
	 * 4)接下来是*运算符，因此弹出5和7，计算出7*5=35，将35入栈；
	 * 5)将6入栈；
	 * 6)最后的运算符是-，计算出35-6=29，由此得出最终结果；
	 */
	
	public static int calculate(List<String> list) {
		//创建栈，只需要一个栈即可
		Stack<String> stack = new Stack<>();
		//遍历list
		for (String item : list) {
			//这里使用正则表达式来取出树
			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 ("+".equals(item)) {
					res = num2 + num1;
				} else if ("-".equals(item)) {
					res = num2 - num1;
				} else if("*".equals(item)) {
					res = num2 * num1;
				} else if("/".equals(item)) {
					res = num2 / num1;
				} else {
					throw new RuntimeException("运算符有误！");
				}
				stack.push(String.valueOf(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 item) {
		int result = 0;
		
		switch (item) {
		case "+":
			result = ADD;
			break;
		case "-":
			result = SUB;
			break;
		case "*":
			result = MUL;
			break;
		case "/":
			result = DIV;
			break;
		default:
			//可能是"("，此时返回0，优先级最低，上面循环终止
			break;
		}
		
		return result;
	}
}

------此文章总结改造来自韩顺平老师讲解的java数据结构与算法