补交20145226蓝墨云班课 -- 后缀表达式

蓝墨云班课 -- 后缀表达式

具体描述：

后缀表达式

内容：

基本概念

后缀表达式，也叫逆波兰式，不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则，如：(2 + 1) * 3 ， 后缀表达式即为2 1 + 3 *。

后缀表达式计算：

建立一个栈S 。从左到右读表达式，如果读到操作数就将它压入栈S中，如果读到n元运算符(即需要参数个数为n的运算符)则取出由栈顶向下的n项按操作数运算，再将运算的结果代替原栈顶的n项，压入栈S中 。如果后缀表达式未读完，则重复上面过程，最后输出栈顶的数值则为结束。

具体的代码：

public class MyDC
{

	private final char ADD = '+';

	private final char SUBTRACT = '-';

	private final char MULTIPLY = '*';

	private final char DIVIDE = '/';

	private Stack<Integer> stack = new Stack<Integer>();

	public MyDC()
	{
		stack = new Stack<Integer>();
	}
	public int evaluate (String expr)
	{
		int op1, op2, result = 0;
		String token;
		String[] p = expr.split("");
		for(int i = 0; i<p.length;i++){
			token = p[i];
			if (isOperator(token))
			{
				op2 = (stack.pop()).intValue();
				op1 = (stack.pop()).intValue();
				result = evalSingleOp (token.charAt(0), op1, op2);
				stack.push (new Integer(result));
			}
			else{
				stack.push (new Integer(Integer.parseInt(token)));
			}
		}
		
		return result;
	}

	private boolean isOperator (String token)
	{
		return ( token.equals("+") || token.equals("-") ||
				token.equals("*") || token.equals("/") );
	}
	private int evalSingleOp (char operation, int op1, int op2)
	{
		int result = 0;

		switch (operation)
		{
		case ADD:
			result = op1 + op2;
			break;
		case SUBTRACT:
			result = op1 - op2;
			break;
		case MULTIPLY:
			result = op1 * op2;
			break;
		case DIVIDE:
			result = op1 / op2;
		}

		return result;
	}
}    

中缀表达式转为后缀表达式过程：

1. 设立一个栈，存放运算符，首先栈为空；
2. 从左到右扫描中缀式，若遇到操作数，直接输出，并输出一个空格作为两个操作数的分隔符；
3. 若遇到运算符，则与栈顶比较，比栈顶级别高则进栈，否则退出栈顶元素并输出，然后输出一个空格作分隔符；
4. 若遇到左括号，进栈；若遇到右括号，则一直退栈输出，直到退到左括号止。
5. 当栈变成空时，输出的结果即为后缀表达式。

具体的代码为：

public class MyBC {
	/** 
	 * 优先级比较 
	 * @param operator1 比较值 
	 * @param operator2 被比较值 
	 * @return 小于等于返回false,大于返回true 
	 */  
	public 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;  
	}  

	public 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]);  
	}  

	
}