前缀表达式

举例：(3+4)*5-6 对应前缀表达式为 - * + 3 4 5 6

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

从右至左扫描，将 6 5 4 3压入堆栈；
遇到+运算符，因此弹出 3 和 4（3 为栈顶元素，4 为次顶元素），计算出 3+4 的值，得 7，再将 7 入栈；
将 5 入栈；
接下来是×运算符，因此弹出 7 和 5，计算出 7×5=35，将 35 入栈；
最后是-运算符，计算出 35-6 的值，即 29，由此得出最终结果

中缀表达式

后缀表达式（逆波兰）

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

从左至右扫描，将 3 和 4 压入堆栈；
遇到+运算符，因此弹出 4 和 3（4 为栈顶元素，3 为次顶元素），计算出 3+4 的值，得 7，再将 7 入栈；
将 5 入栈；
接下来是×运算符，因此弹出 5 和 7，计算出 7×5=35，将 35 入栈；
将 6 入栈；
最后是-运算符，计算出 35-6 的值，即 29，由此得出最终结果

逆波兰计算器

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

代码实现

public class PolandNotation {

	public static void main(String[] args) {
		// 定义逆波兰表达式
		// (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 * 6 -
		// 为了方便数字和符号用空格隔开
		String suffixExpression = "3 4 + 5 * 6 - ";// 29

		// 思路
		// 1.先将"3 4 + 5 * 6 -"放到ArrayList中
		// 2.将ArrayList传给一个方法，配合栈 完成运算

		List<String> List = getListString(suffixExpression);
		System.out.println("rpnList=" + List);

		int res = calculate(List);
		System.out.println("计算的结果是=" + res);
	}

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

	// 完成逆波兰表示式运算，扫描表达式变成对list的遍历
	public static int calculate(List<String> ls) {
		// 创建栈，只需要一个栈
		Stack<String> stack = new Stack<String>();
		// 遍历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);// 整数转字符串
			}
		} // for
			// 最后留在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”转换为后缀表达式"1 2 3 + 4 × + 5 –"