Java数据结构与算法———（25）将中缀表达式转换成后缀表达式

将一个中缀表达式转换成后缀表达式。

一、代码

package stack;

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

public class PolandNotation {

	public static void main(String[] args) {
		/*
		// 一、 用栈计算后缀表达式
		// 先定义一个逆波兰表达式（字符串）
		// (3+4)x5-6 => 3 4 + 5 x 6 -
		// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
		// 为了方便，逆波兰表达式的数字和符号之间要用空格隔开
		String suffixExpression = "4 5 * 8 - 60 + 8 2 / +";
		// 思路:
		// 1. 先将"3 4 + 5 x 6 - "放到 ArrayList 中
		// 2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈完成计算
		List<String> list = getListString(suffixExpression);
		System.out.println("rpnList = " + list);
		try {
			int res = cal(list);
			System.out.println("计算结果 = " + res);
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		*/
		
		//二、将一个中缀表达式转换成后缀表达式
		//说明
		//1. 1+((2+3)x4)-5 => 1 2 3 + 4 x + 5 -
		//2. 因为直接对表达式字符串"1+((2+3)x4)-5"进行操作不方便，因此先将"1+((2+3)x4)-5"转换成中缀表达式对应的List
		//3. 即中缀表达式字符串"1+((2+3)x4)-5"转换成中缀表达式ArrayList [1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
		
		String expression = "1+((2+3)x4)-5";//中缀表达式字符串
		List<String> infixExpressionList = toInfixExpressionList(expression);
		System.out.println("中缀表达式："+ expression + "对应的后缀表达式为："+infixExpressionList);
	}

	// 方法：将中缀表达式（字符串）转换成对应的List
	public static List<String> toInfixExpressionList(String s) {
		// 先定义一个List，存放中缀表达式（字符串）的内容
		List<String> ls = new ArrayList<String>();
		int index = 0;// 这是一个指针，用于遍历中缀表达式字符串s
		String str;// 用于对多位数进行拼接，一定要注意每次拼接前都要赋值为空串""
		char c;// 没遍历到一个字符，就放入到c中
		do {
			// 如果c是一个非数字，就需要加入到ls中
			if ((c = s.charAt(index)) < 48 || (c = s.charAt(index)) > 57) {
				// ASCII码大于等于48，小于等于57之间的为数字字符
				ls.add("" + c);
				index++;// index后移一位
			} else {// 如果是一个数，需要考虑多位数
				str = "";// 每次拼接前都要赋值为空串""
				while (index < s.length() && (c = s.charAt(index)) >= 48 && (c = s.charAt(index)) <= 57) {
					// '0'的ASCII码为48，'9'的ASCII码为57
					str += c;// 拼接成多位数
					index++;// index后移一位
				}
				ls.add(str);// 拼接完后，就将其放入ls中
			}
		} while (index < s.length());// while循环结束后，就已经完成了转换
		return ls;
	}

	// 依次将一个逆波兰表达式的数字和运算符放入到ArrayList中
	public static List<String> getListString(String suffixExpression) {
		// 将字符串 suffixExpression 分割成单个字符串（不包括空格字符串" "），然后放入一个字符串数组
		// suffixExpression.split(" ")表示以空格字符串" "作为分隔符将suffixExpression分割成单个的字符串
		String[] split = suffixExpression.split(" ");
		List<String> list = new ArrayList<String>();
		for (String e : split) {
			list.add(e);
		}
		return list;
	}

	// 完成对逆波兰表达式 3 4 + 5 x 6 - 的运算
	// 1.从左至右扫描，将3和4压入堆栈；
	// 2.遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4=7，再将7入栈；
	// 3.将5入栈；
	// 4.接下来是x运算符，因此弹出5和7，计算7x5=35，将25入栈； 5)将6入栈； 6)最后是-运算符，计算出35-6=29，由此得出最终结果。

	public static int cal(List<String> ls) {
		// 创建一个栈，只需要一个栈即可，栈中存放的是字符串
		Stack<String> stack = new Stack<String>();
		// 遍历传入的ls
		for (String e : ls) {
			// 这里使用正则表达式取出数
			if (e.matches("\\d+")) {// 匹配的是多位数
				stack.push(e);// 如果e是一个数，则直接入栈
			} else {
				// 如果e不是数，则pop出两个数，并运算，再入栈
				// 注意：先弹出的数用num2接收，后弹出的数用num1接收
				int num2 = Integer.parseInt(stack.pop());// 出栈的字符串，所以要转换成整型数值
				int num1 = Integer.parseInt(stack.pop());
				int res = 0;// 用于存放num2和num1的计算结果
				if (e.equals("+")) {// 如果扫描到运算符是+
					res = num1 + num2;// 注意：先弹出的数用num2接收，后弹出的数用num1接收
				} else if (e.equals("-")) {
					// 注意：先弹出的数用num2接收，后弹出的数用num1接收，所以res = num1 - num2
					// 如果先弹出的数用num1接收，后弹出的数用num2接收，则res = num2 - num1
					res = num1 - num2;
				} else if (e.equals("*")) {
					res = num1 * num2;
				} else if (e.equals("/")) {
					// 注意：先弹出的数用num2接收，后弹出的数用num1接收，所以res = num1/num2
					// 如果先弹出的数用num1接收，后弹出的数用num2接收，则res = num2/num1
					res = num1 / num2;
				} else {// 如果运算符不是+、-、*、/中的一个，则抛出异常
					throw new RuntimeException("运算符有误");
				}
				// 把运算结果res入栈
				stack.push("" + res);// 栈stack上一个字符串栈，而res是整数，所以要将res变成"res"才能入栈
			}
		}
		// 最后留在stack中的数据就是运算结果
		// 注意：stack.pop()的结果是一个字符串，要将字符串转换成int
		return Integer.parseInt(stack.pop());
	}
}

二、结果

中缀表达式：1+((2+3)x4)-5对应的后缀表达式为：[1, +, (, (, 2, +, 3, ), x, 4, ), -, 5]