表达式求值 - Java实现

本程序用于计算任意四则运算表达式。如 4 * ( 10 + 2 ) + 1 的结果应该为 49。

算法说明：

1. 首先定义运算符优先级。我们用一个

Map<String, Map<String, String>>

来保存优先级表。这样我们就可以通过下面的方式来计算两个运算符的优先级了：

/**
	 * 查表得到op1和op2的优先级
	 * @param op1 运算符1
	 * @param op2 运算符2
	 * @return ">", "<" 或 "="
	 */
	public String priority(String op1, String op2) {
		return priorityMap.get(op1).get(op2);
	}

2. 扫描表达式字符串，每次读入一个 token 进行处理。

使用两个辅助栈：optStack用于保存运算符，numStack用于保存操作数. 我们用 '#' 作为表达式的起始和结果标志符。

读入一个token，如果它是数字，则压入numStack栈中；

如果它是运算符，则取出optStack栈的栈顶元素A，将 A 与 token 进行优先级比较。

如果 A < token，则将 token 压入optStack栈。

如果 A = token，则说明 token和A是一对括号，此时将optStack栈的栈顶元素弹出。

如果 A > token，则从numStack中弹出２个操作数，从optStack中弹出1个运算符，并计算结果。

当optStrack栈为空时（即栈顶元素为 '#'），numStack栈的栈顶元素即为表达式的值。

算法实现：

/**
 * 算术表达式求值。
 * 3 + 4 * 12 结果为51
 * @author whf
 *
 */
public class EvaluateExpression {
	// 运算符优先级关系表
	private Map<String, Map<String, String>> priorityMap = new HashMap<String, Map<String, String>>();
	
	private LinkedStack<String> optStack = new LinkedStack<String>(); // 运算符栈
	private LinkedStack<Double> numStack = new LinkedStack<Double>(); // 操作数栈
	
	
	/**
	 * 计算表达式
	 * @param exp 四则运算表达式, 每个符号必须以空格分隔
	 * @return
	 */
	public double calcualte(String exp) {
		StringTokenizer st = new StringTokenizer(exp);
		while (st.hasMoreTokens()) {
			String token = st.nextToken();
			process(token);
		}
		
		return numStack.pop();
	}
	
	/**
	 * 读入一个符号串。
	 * 如果是数字，则压入numStack
	 * 如果是运算符，则将optStack栈顶元素与该运算符进行优先级比较
	 * 如果栈顶元素优先级低，则将运算符压入optStack栈,如果相同，则弹出左括号，如果高，则取出２个数字，取出一个运算符执行计算，然后将结果压入numStack栈中
	 * @param token
	 */
	private void process(String token) {
		while (false == "#".equals(optStack.getTop()) || false == token.equals("#")) {
			
			// token is numeric
			if (true == isNumber(token)) {
                numStack.push(Double.parseDouble(token));
                break;
        
                // token is operator
			} else {
                String priority = priority(optStack.getTop(), token);
                
                if ("<".equals(priority)) {
                	optStack.push(token);
                	break;
                } else if ("=".equals(priority)) {
                	optStack.pop();
                	break;
                } else {
                    double res = calculate(optStack.pop(), numStack.pop(), numStack.pop());
                    numStack.push(res);
                }
			}
		}
		
	}
	
	/**
	 * 执行四则运算
	 * @param opt
	 * @param n1
	 * @param n2
	 * @return
	 */
	private double calculate(String opt, double n1, double n2) {
		if ("+".equals(opt)) {
			return n2 + n1;
		} else if ("-".equals(opt)) {
			return n2 - n1;
		} else if ("*".equals(opt)) {
			return n2 * n1;
		} else if ("/".equals(opt)) {
			return n2 / n1;
		} else {
			throw new RuntimeException("unsupported operator:" + opt);
		}
	}
	
	/**
	 * 检查一个String是否为数字
	 * @param token
	 * @return
	 */
	private boolean isNumber(String token) {
		int LEN = token.length();
		for (int ix = 0 ; ix < LEN ; ++ix) {
			char ch = token.charAt(ix);
			// 跳过小数点
			if (ch == '.') {
				continue;
			}

			if (false == isNumber(ch)) {
				return false;
			}
		}
		
		return true;
	}
	
	/**
	 * 检查一个字符是否为数字
	 * @param ch
	 * @return
	 */
	private boolean isNumber(char ch) {
		if (ch >= '0' && ch <= '9') {
			return true;
		}
		
		return false;
	}
	
	/**
	 * 查表得到op1和op2的优先级
	 * @param op1 运算符1
	 * @param op2 运算符2
	 * @return ">", "<" 或 "="
	 */
	public String priority(String op1, String op2) {
		return priorityMap.get(op1).get(op2);
	}
	
	/**
	 * 构造方法，初始化优先级表
	 */
	public EvaluateExpression() {
		// initialize stack
		optStack.push("#");
		
		// initialize priority table
		// +
		Map<String, String> subMap = new HashMap<String, String>();
		subMap.put("+", ">");
		subMap.put("-", ">");
		subMap.put("*", "<");
		subMap.put("/", "<");
		subMap.put("(", "<");
		subMap.put(")", ">");
		subMap.put("#", ">");
		priorityMap.put("+", subMap);
		
		// -
		subMap = new HashMap<String, String>();
		subMap.put("+", ">");
		subMap.put("-", ">");
		subMap.put("*", "<");
		subMap.put("/", "<");
		subMap.put("(", "<");
		subMap.put(")", ">");
		subMap.put("#", ">");
		priorityMap.put("-", subMap);

		// *
		subMap = new HashMap<String, String>();
		subMap.put("+", ">");
		subMap.put("-", ">");
		subMap.put("*", ">");
		subMap.put("/", ">");
		subMap.put("(", "<");
		subMap.put(")", ">");
		subMap.put("#", ">");
		priorityMap.put("*", subMap);
		
		// /
		subMap = new HashMap<String, String>();
		subMap.put("+", ">");
		subMap.put("-", ">");
		subMap.put("*", ">");
		subMap.put("/", ">");
		subMap.put("(", "<");
		subMap.put(")", ">");
		subMap.put("#", ">");
		priorityMap.put("/", subMap);

		// (
		subMap = new HashMap<String, String>();
		subMap.put("+", "<");
		subMap.put("-", "<");
		subMap.put("*", "<");
		subMap.put("/", "<");
		subMap.put("(", "<");
		subMap.put(")", "=");
		//subMap.put("#", ">");
		priorityMap.put("(", subMap);

		// )
		subMap = new HashMap<String, String>();
		subMap.put("+", ">");
		subMap.put("-", ">");
		subMap.put("*", ">");
		subMap.put("/", ">");
		//subMap.put("(", "<");
		subMap.put(")", ">");
		subMap.put("#", ">");
		priorityMap.put(")", subMap);

		// #
		subMap = new HashMap<String, String>();
		subMap.put("+", "<");
		subMap.put("-", "<");
		subMap.put("*", "<");
		subMap.put("/", "<");
		subMap.put("(", "<");
		//subMap.put(")", ">");
		subMap.put("#", "=");
		priorityMap.put("#", subMap);
	}

}

程序测试：

String exp = "4 * ( 10 + 2 ) + 1 #";
		EvaluateExpression ee = new EvaluateExpression();

		out.println(ee.calcualte(exp));

运行结果为 49。