栈应用之中缀到后缀表达式的转换

栈操作是常数时间操作，后缀表达式花费的是O(N).

中缀转后缀表达式算法描述：

（1）遇到操作数，直接输出；

（2）栈为空时，遇到操作符，入栈；

（3）遇到左括号、入栈；

（4）遇到右括号，执行出栈操作，并输出出栈元素，直到遇到左括号，左括号不输出；

（5）遇到其他运算符'+''-''*''/'时，弹出所有优先级大于或等于该操作符的栈顶元素，然后将该操作符入栈；

（6）最终将栈中的元素依次出栈，输出。

经过上面的步骤，得到的输出既是转换得到的后缀表达式。

举例：a+b*c+(d*e+f)*g ---------> abc*+de*f+g*+

public class InToPostfix {
	private Stack<Character> s;
	private String input;
	private String output="";

	public InToPostfix(String input) {
		this.input = input;
		s = new Stack<Character>();
	}

	public String doTrans(){
		for(int i=0; i<input.length(); i++){
			char c = input.charAt(i);
			switch(c){
			//2.栈为空时，遇到操作符，入栈
			//3.遇到其他运算符'+''-''*''/'时，弹出所有优先级大于或等于该操作符的栈顶元素，然后将该操作符入栈；
			case '+':
			case '-':
				gotOper(c,1);
				break;
			case '*':
			case '/':
				gotOper(c,2);
				break;	
			//4.遇到（，入栈
			case '(':
				s.push(c);
				break;
			//5.遇到），出栈，只接输出，直到遇到（，不输出
			case ')':
				gotParent();
				break;
			//1遇到操作数，直接输出
			default:
				output +=c;
				break;
			}
		}
		//6.最后将栈中的元素全部输出
		while(!s.isEmpty()){
			output += s.pop();
		}
		return output;
	}

	private void gotOper(char ch, int prior1){
		while(!s.isEmpty()){
			char top = (char) s.pop();
			if(top=='('){
				s.push(top);
				break;
			}else{
				int prior2;
				if(top=='+'||top=='-'){
					prior2 = 1;
				}else{
					prior2 = 2;
				}
				if(prior2 < prior1){
					s.push(top);
					break;
				}else{
					output += top;
				}
			}
		}
		s.push(ch);
	}
	
	private void gotParent(){
		while(!s.isEmpty()){
			char c = (char) s.pop();
			if(c != '('){
				output += c;
			}else{
				break;
			}
		}
	}
	public static void main(String[] args) {
		String input = "a+b*c+(d*e+f)*g";
		
		InToPostfix inTo = new InToPostfix(input);
		String output =inTo.doTrans();
		System.out.println(output);
	}
}