中缀表达式转后缀表达式的java实现

这个应该是科班出身的程序员在学习离散数学的时候都学过的知识点。

大家或许自己用笔写出后缀表达式很容易，但是用代码实现就感觉无从下手，就只知道用栈，究竟如何用。

public class Caculator {

	private int priority(char c){
		if(c == ‘*‘ || c== ‘/‘)
			return 2;
		else if(c == ‘+‘ || c== ‘-‘)
			return 1;
		else
			return 0;
	}

	private boolean leftPirorityIsNotLess(Character c1,char c2){
		if(c1 == null)return false;
		return priority(c1)>=priority(c2);
	}
	private boolean isNumber(char c){
		if(‘0‘ <= c && c<=‘9‘)return true;
		return false;
	}
	private boolean isLeftBracket(char c){
		if(c == ‘(‘)return true;
		return false;
	}
	private boolean isRightBracket(char c){
		if(c == ‘)‘)return true;
		return false;
	}
	private boolean isOperator(char c){
		if(c == ‘+‘ || c == ‘-‘ || c == ‘*‘ ||c == ‘/‘)return true;
		return false;
	}

	public Caculator(){
	}

	public String parse(String str){
		class Stack<T>{
			private LinkedList<T> list = new LinkedList<T>();

			public void push(T t){
				list.addLast(t);
			}

			public T pop(){
				return list.removeLast();
			}

			public T top(){
				return list.peekLast();
			}

			public boolean isEmpty(){
				return list.isEmpty();
			}
		}

		Stack<Character> stack = new Stack<>();
		StringBuilder sb = new StringBuilder();
		char[] cs = str.toCharArray();

		for(int i=0; i<cs.length; ++i){
			char c = cs[i];
			if( isNumber(c)){
				sb.append(c);

			}else if( isLeftBracket(c)){
				stack.push(c);

			}else if( isOperator(c)){
			        //sb.append("‘");//分开左右两个数
				while( leftPirorityIsNotLess(stack.top(), c)){
					sb.append( stack.pop());
				}
				stack.push(c);

			}else if( isRightBracket(c)){
				while( !isLeftBracket( stack.top())){
					sb.append(stack.pop());
				}
				stack.pop();
			}
		}

		while( !stack.isEmpty()){
			sb.append(stack.pop());
		}

		return sb.toString();
	}

	public static void main(String[] args) {
		String str = "8-7*((5+5)-8)/2+7";
		Caculator ca = new Caculator();
		System.out.println( ca.parse(str));
	}

}

从代码的角度自己写一遍代码运行的过程就能大概明白栈在这里具体作用了。

上面代码还可以改进，因为数的位数是很多位时，你需要区分两个贴在一起的数的分解。上面注释的代码是一个方法，但是不完美。