四则运算 栈的运用

中心：
1.createHouzhui 建立后缀表达式
数字 -》 push到数据栈
运算符 -》

1. （ 或运算符栈空 ----- 直接入栈
2. ）----- 则pop出运算符栈的运算符到数据栈中，直到找到一个)
3. ±*/ -----如果优先级大于栈顶元素，直接入栈。如果小于或等于，则pop出运算符栈的运算符到数据栈中，直到优先级大于栈顶元素优先级，入栈

总的来说，运算符栈中，栈顶到栈底 优先级 高 -》 低

4. 结束循环后，把运算符栈pop到数据栈
5. 数据栈中元素全部pop

package huawei;

import java.util.HashMap;
import java.util.Scanner;
import java.util.Stack;

public class test4 {

	static HashMap<String, Integer> priorityMap = new HashMap<String, Integer>();
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		priorityMap.put("(", 0);
		priorityMap.put("+", 1);
		priorityMap.put("-", 1);
		priorityMap.put("*", 2);
		priorityMap.put("/", 2);
		
		
		Scanner scanner = new Scanner(System.in);
		String equation = scanner.nextLine();
		Stack<String> teStrings = createHouzhui(equation);
//		while (!teStrings.empty()) {
//			System.out.println(teStrings.pop());
//		}
//		
//		String string[] = {"1", "2", "3", "+", "4", "*", "+", "5", "-"};
		System.out.println(calculateOperaters(teStrings));
	}
	public static Stack<String> createHouzhui(String string) {
		char[] strings = string.toCharArray();
		Stack<String> operateStack = new Stack<String>();
		Stack<String> numberStack = new Stack<String>();
		
		Character value;
		Integer temp_number = 0;
		for (int i = 0; i < strings.length; i++) {
			value = strings[i];
			if (value >= '0' && value <= '9') {
				temp_number = temp_number * 10 + value - '0';
				if (i + 1 < strings.length ) {
					if (!(strings[i + 1] >= '0' && strings[i + 1] <= '9')) {
						numberStack.push(temp_number.toString());
						temp_number = 0;
					}
				} else if (i == strings.length - 1) {
					numberStack.push(temp_number.toString());
				}
			} else if (value == '(' || operateStack.empty()) {
				operateStack.push(value.toString());
			} else {
				// )  pop到numberStack中直到找到（
				if (value == ')') {
					while (! "(".equals(operateStack.peek())) {
						numberStack.push(operateStack.pop());
					}
					operateStack.pop();
				} else {
					String topValue = operateStack.peek();
					
					if (priorityMap.get(topValue) < priorityMap.get(value.toString())) {
						operateStack.push(value.toString());
					} else {
						while (!operateStack.empty() && (priorityMap.get(topValue) >= priorityMap.get(value.toString()))) {
							numberStack.push(topValue);
							topValue = operateStack.pop();
						}
						operateStack.push(value.toString());
					}
				}
			}
		}
		
		while (!numberStack.empty()) {
			operateStack.push(numberStack.pop());
		}
		
		return operateStack;
	}
	public static int calculateOperaters(Stack<String> strings) {
		Stack<Integer> stackResult = new Stack<Integer>();
		while(!strings.empty()) {
			String value = strings.pop();
			if (priorityMap.containsKey(value)) {
				int value1 = stackResult.pop();
				int value2 = stackResult.pop();
				int result = calculate(value1, value2, value);
				stackResult.push(result);
			} else {
				stackResult.push(Integer.parseInt(value));
			}
			
		}
		return stackResult.pop();
	}
	private static int calculate(int value1, int value2, String value) {
		// TODO Auto-generated method stub
		if ("+".equals(value)) {
			return value1 + value2;
		} else if ("-".equals(value)) {
			return value2 - value1;
		} else if ("*".equals(value)) {
			return value2 * value1;
		} else {
			return value2 / value1;
		} 
	}
}