逆波兰式计算字符串公式

package t201401;

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

public class T1502 {
	
	/**
	 * 优先级比较
	 * @param operator1 比较值
	 * @param operator2 被比较值
	 * @return 小于等于返回false,大于返回true
	 */
	static boolean comparePrior(String operator1, String operator2) {
		if("(".equals(operator2)) {
			return true;
		}
		if ("*".equals(operator1) || "/".equals(operator1)) {
			if ("+".equals(operator2) || "-".equals(operator2)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 转为后缀表达式:
	 * 1、如果是"("直接压入stack栈。
 	 * 2、如果是")"，依次从stack栈弹出运算符加到数组newExpressionStrs的末尾，知道遇到"("；
 	 * 3、如果是非括号，比较扫描到的运算符，和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组newExpressionStrs的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中。就这样依次扫描，知道结束为止。如果扫描结束，栈中还有元素，则依次弹出加到数组newExpressionStrs的末尾，就得到了后缀表达式。
	 * @param expressionStrs
	 * @return
	 */
	static String[] toSuffixExpression(String[] expressionStrs) {
		//新组成的表达式
		List<String> newExpressionStrs = new ArrayList<String>();
		Stack<String> stack = new Stack<String>();
		for (int i = 0; i < expressionStrs.length; i++) {
			if ("(".equals(expressionStrs[i])) { // 如果是左括号,则入栈
				stack.push(expressionStrs[i]);
			} else if ("+".equals(expressionStrs[i]) || "-".equals(expressionStrs[i]) || "*".equals(expressionStrs[i]) || "/".equals(expressionStrs[i])) {
				if (!stack.empty()) { // 取出先入栈的运算符
					String s = stack.pop();
					if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈
						stack.push(s);
					} else {  //否则取出值
						newExpressionStrs.add(s);
					}
				}
				stack.push(expressionStrs[i]);
			} else if (")".equals(expressionStrs[i])) { //如果是")",则出栈,一直到遇到"("
				while (!stack.empty()) {
					String s = stack.pop();
					if (!"(".equals(s)) {
						newExpressionStrs.add(s);
					} else {
						break;
					}
				}
			} else {
				newExpressionStrs.add(expressionStrs[i]);
			}
		}
		while (!stack.empty()) {
			String s = stack.pop();
			newExpressionStrs.add(s);
		}
		return newExpressionStrs.toArray(new String[0]);
	}

	public static void main(String[] args) {
		
		//要用的字符串表达式
		String expressionStr = "a+b/(a+a)+c";
		Map<String,Double> map = new HashMap<String,Double>();
		map.put("a", 1.0);
		map.put("b", 2.0);
		map.put("c", 3.0);
		
		
		// 分割成表达式数组
		String[] strs = expressionStr.split("");
		String[] newStrs = toSuffixExpression(strs);
		Stack<Double> stack = new Stack<Double>();
		Double cache;
		for (int i = 0; i < newStrs.length; i++) {
			if ("*".equals(newStrs[i])){
				stack.push(stack.pop()*stack.pop());
			}else if("/".equals(newStrs[i])){
				cache = stack.pop();
				stack.push(stack.pop()/cache);
			}else if("+".equals(newStrs[i])){
				stack.push(stack.pop()+stack.pop());
			}else if("-".equals(newStrs[i])){
				cache = stack.pop();
				stack.push(stack.pop()-cache);
			}else{
				stack.push(map.get(newStrs[i]));
			}
		}
		
		System.out.println(stack.pop());
	}

}

版权声明：本文为博主原创文章，未经博主允许不得转载。