NYOJ35-表达式求值（逆波兰式）java

表达式求值

描述

ACM队的mdd想做一个计算器，但是，他要做的不仅仅是一计算一个A+B的计算器，他想实现随便输入一个表达式都能求出它的值的计算器，现在请你帮助他来实现这个计算器吧。
比如输入：“1+2/4=”，程序就输出1.50（结果保留两位小数）

输入

第一行输入一个整数n，共有n组测试数据（n<10)。
每组测试数据只有一行，是一个长度不超过1000的字符串，表示这个运算式，每个运算式都是以“=”结束。这个表达式里只包含+-*/与小括号这几种符号。其中小括号可以嵌套使用。数据保证输入的操作数中不会出现负数。
数据保证除数不会为0

输出

每组都输出该组运算式的运算结果，输出结果保留两位小数。

样例输入

2
1.000+2/4=
((1+2)*5+1)/4=

样例输出

1.50
4.00

哎，好长时间不刷题，写加调得用了一下午，然后提交居然超时，然后又花时间去优化，哎。下面讲下这个题。

以前学数据结构中，栈那一章讲过这种题型，典型的用栈来实现。关于何为逆波兰式自己百度下吧，很多博客都有说的，我就直接上代码吧。

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

public class Main {
	/*
	 * 2 1.000+3/1= 
	 * ((1+2)*5+1)/4=
	 */
	public static float houZhui(String formula) {
		Stack<String> s1 = new Stack<String>();//放逆波兰式
		Stack<String> s2 = new Stack<String>();//放操作符
		HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
		hashMap.put("(", 0);// 设定优先级 +-优先级相同 */优先级相同
		hashMap.put("+", 1);
		hashMap.put("-", 1);
		hashMap.put("*", 2);
		hashMap.put("/", 2);
		for (int i = 0; i < formula.length();) {
			StringBuffer digit = new StringBuffer();
			char c = formula.charAt(i);
			while (Character.isDigit(c) || c == '.') {
				digit.append(c);
				i++;
				c = formula.charAt(i);
			}
			if (digit.length() == 0) {
				switch (c) {
				  case '(': {
					s2.push(String.valueOf(c));
					break;
				  }
				  case ')': {//操作符为）则将s2中操作符除(都放入s1
					String stmp = s2.pop();
					while (!s2.isEmpty() && !stmp.equals("(")) {
						s1.push(stmp);
						stmp = s2.pop();
					}
					break;
				  }
				  case '=': {//若s2中还有操作符则入s1    逆波兰式构造结束
					String stmp;
					while (!s2.isEmpty()) {
						stmp = s2.pop();
						s1.push(stmp);
					}
					s1.push("=");
					break;
				  }
				  default: {//若操作符为+-*/
					String stmp;
					while (!s2.isEmpty()) {
						stmp = s2.pop();
						/*当前遍历的运算符的优先级小于栈顶运算符的优先级，
						则将栈顶运算符一直出栈加入到栈S1中，
						直到栈为空或者遇到一个运算符的优先级小于等于当前遍历的运算符的优先级，
						此时将该运算符加入到栈S2中；*/
						if (hashMap.get(stmp) >= hashMap.get(String.valueOf(c))) {
							s1.push(stmp);
						} else {
							s2.push(stmp);//这个运算符得放回，因为用的pop会取出s2的顶，而取到的栈顶运算符优先级高
							break;
						}
					}
					s2.push(String.valueOf(c));//将当前运算符放入
					break;
				  }
				 }
			} else {//数字时，直接放入s1
				s1.push(digit.toString());
				continue;
			}
			i++;
		}
		ArrayList<String> stmp = new ArrayList<String>();
		for (String s : s1) {
			stmp.add(s);
		}
		return calc(stmp);
	}

	public static float calc(ArrayList<String> formula) {// 计算逆波兰式
		Stack<Float> result = new Stack<Float>();
		float res = 0f;
		for (int i = 0; i < formula.size(); i++) {
			String c = formula.get(i);
			if (c.length() == 1 && (!Character.isDigit(c.charAt(0)))) {
				float a = Float.valueOf(result.pop());
				float b = Float.valueOf(result.pop());
				if (c.equals("+")) {
					result.push(b + a);
				} else if (c.equals("-")) {
					result.push(b - a);
				} else if (c.equals("*")) {
					result.push(b * a);
				} else if (c.equals("/")) {
					result.push(b / a);
				} else {
					res = result.pop();
				}
			} else {
				result.push(Float.valueOf(c));
			}
		}
		return res;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		while (n > 0) {
			String s = scanner.next();
			System.out.printf("%.2f\n", houZhui(s));
			n--;
		}

	}

}

但是呢，这个最常规的，先计算逆波兰式，然后再计算值提交后显示超时，哎，想了想，有很多步骤都多余了，因为s1首先放入的是两个数字，然后再会放入操作符，意思就是每回要将操作符放入s1中的时候，s1中必定有两个数字，而且是计算中要操作的步骤。这样就提供了优化。在构造逆波兰式的时候进行计算，构造完也就计算完了，下面是改进的优化代码。提交后成功。

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

public class Main {
	/*
	 * 2 1.000+3/1= ((1+2)*5+1)/4=
	 */
	public static float houZhui(String formula) {
		Stack<Float> s1 = new Stack<Float>();//放数字
		Stack<String> s2 = new Stack<String>();//放操作符
		HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
		hashMap.put("(", 0);
		hashMap.put("+", 1);
		hashMap.put("-", 1);
		hashMap.put("*", 2);
		hashMap.put("/", 2);
		int tiao = 0;
		for (int i = 0; i < formula.length();) {
			StringBuffer digit = new StringBuffer();
			char c = formula.charAt(i);
			while (Character.isDigit(c) || c == '.') {
				digit.append(c);
				i++;
				c = formula.charAt(i);
			}
			if (digit.length() == 0) {
				switch (c) {
				case '(': {
					s2.push(String.valueOf(c));
					break;
				}
				case ')': {
					String stmp = s2.pop();
					while (!s2.isEmpty() && !stmp.equals("(")) {
						float a = s1.pop();
						float b = s1.pop();
						float sresulat = calcFloat(b, a, stmp);
						s1.push(sresulat);
						stmp = s2.pop();
					}
					break;
				}
				case '=': {
					String stmp;
					while (!s2.isEmpty()) {
						stmp = s2.pop();
						float a = s1.pop();
						float b = s1.pop();
						float sresulat = calcFloat(b, a, stmp);
						s1.push(sresulat);
					}
					break;
				}
				default: {
					String stmp;
					while (!s2.isEmpty()) {
						stmp = s2.pop();
						if (hashMap.get(stmp) >= hashMap.get(String.valueOf(c))) {
							float a = s1.pop();
							float b = s1.pop();
							float sresulat = calcFloat(b, a, stmp);
							s1.push(sresulat);

						} else {
							s2.push(stmp);
							break;
						}

					}
					s2.push(String.valueOf(c));
					break;
				}
				}
			} else {
				s1.push(Float.valueOf(digit.toString()));
				continue;
			}
			i++;
		}
		return s1.peek();
	}

	public static float calcFloat(float a, float b, String stmp) {
		float res = 0f;
		char s = stmp.charAt(0);
		switch (s) {
		  case '+': {
			res = a + b;
			break;
		  }
		  case '-': {
			res = a - b;

			break;
		  }
		  case '*': {
			res = a * b;
			break;
		  }
		  case '/': {
			res = a / b;
			break;
		  }
		}
		return res;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		while (n > 0) {
			String s = scanner.next();
			System.out.printf("%.2f\n", houZhui(s));
			n--;
		}
	}

}

这个程序就是将第一个程序中的，所有s1.push（操作符）改为了计算然后放入结果。这样s1这个Stack的泛型弄Float就行。

这是本人的一点肤见，大家看看就好~欢迎交流