Basic Calculator

问题描述

Implement a basic calculator to evaluate a simple expression string.

The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .

You may assume that the given expression is always valid.

Some examples:

"1 + 1" = 2
" 2-1 + 2 " = 3
"(1+(4+5+2)-3)+(6+8)" = 23

 

Note: Do not use the eval built-in library function. 

 

程序

第一种是普通的方法：先将表达式转成后缀表达式，然后再计算。（TLE）

将中缀表达式转为后缀表达式

中缀表达式转为后缀表达式的要点：

开始扫描；

数字时，加入后缀表达式；

运算符：

a. 若为 '('，入栈；

b. 若为 ')'，则依次把栈中的的运算符加入后缀表达式中，直到出现'('，从栈中删除'(' ；

c. 若为 除括号外的其他运算符， 当其优先级高于除'('以外的栈顶运算符时，直接入栈。否则从栈顶开始，依次弹出比当前处理的运算符优先级高和优先级相等的运算符，直到一个比它优先级低 的或者遇到了一个左括号为止。·当扫描的中缀表达式结束时，栈中的的所有运算符出栈；  

 

public List<String> getPostfixExpressionList(String s) {
		List<String> list = new ArrayList<String>();

		// preprocess
		s = s.trim();
		char[] cc = s.toCharArray();
		String pro_s = "";
		Stack<String> st = new Stack<String>();

		for (int i = 0; i < cc.length; i++) {
			char c = cc[i];
			if (!Character.isDigit(c)) {
				pro_s += " " + c + " ";
			} else {
				pro_s += c;
			}
		}

		// operators priority
		HashMap<String, Integer> opMap = new HashMap<String, Integer>();
		opMap.put("+", 0);
		opMap.put("-", 0);
		opMap.put("*", 1);
		opMap.put("/", 1);

		String[] items = pro_s.split(" ");
		for (int i = 0; i < items.length; i++) {
			String item = items[i].trim();
			if (item.length() == 0) {
				continue;
			}
			if (item.equals("(")) {
				st.push(item);
			} else if (item.equals(")")) {
				while (!st.peek().equals("(")) {
					list.add(st.pop());
				}
				st.pop();
			} else if (opMap.containsKey(item)) {
				if (st.isEmpty() || st.peek().equals("(")
						|| opMap.get(st.peek()) < opMap.get(item)) {
					st.push(item);
				} else {
					while (!st.isEmpty() && !st.peek().equals("(")
							&& opMap.get(st.peek()) >= opMap.get(item)) {
						list.add(st.pop());
					}
					st.push(item);
				}
			} else {
				list.add(item);
			}
		}
		
		while (!st.isEmpty()) {
			list.add(st.pop());
		}
		
		return list;
	}

　

第二种是简化的方法，比较巧妙。

public class BasicCalculator {
	public int calculate(String s) {
		if (s == null || s.length() == 0) {
			return 0;
		}

		// transform to postfix expression
		BasicCalculatorII bs2 = new BasicCalculatorII();
		List<String> postExpressionList = bs2.getPostfixExpressionList(s);

		// calculate
		Stack<Integer> calStack = new Stack<Integer>();
		for (String ex : postExpressionList) {
			if (ex.equals("+")) {
				int n1 = calStack.pop();
				int n2 = calStack.pop();
				calStack.push(n1 + n2);
			} else if (ex.equals("-")) {
				int n1 = calStack.pop();
				int n2 = calStack.pop();
				calStack.push(n2 - n1);
			} else if (ex.equals("*")) {
				int n1 = calStack.pop();
				int n2 = calStack.pop();
				calStack.push(n2 * n1);
			} else if (ex.equals("/")) {
				int n1 = calStack.pop();
				int n2 = calStack.pop();
				calStack.push(n2 / n1);
			} else {
				calStack.push(Integer.valueOf(ex));
			}
		}

		return calStack.peek();
	}
	
	// only have +, - operators
	public int calculate2(String s) {
		if (s == null || s.length() == 0) {
			return 0;
		}

		s = s.trim();
		int res = 0, sign = 1;
		Stack<Integer> st = new Stack<Integer>();

		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (Character.isDigit(c)) {
				int cur = c - '0';
				while (i + 1 < s.length() && Character.isDigit(s.charAt(i + 1))) {
					cur = cur * 10 + (s.charAt(i + 1) - '0');
					++i;
				}
				res += sign * cur;
			} else if (c == '+') {
				sign = 1;
			} else if (c == '-') {
				sign = -1;
			} else if (c == '(') {
				st.push(res);
				res = 0;
				st.push(sign);
				sign = 1;
			} else if (c == ')') {
				res = st.pop() * res + st.pop();
				sign = 1;
			}
		}

		return res;
	}
}