Java中缀表达式转后缀表达式

我们把平时所用的标准四则运算表达式，即“9+(3-1)*3+10/2”叫做中缀表达式。因为所有的运算符号都在两数字的中间，现在我们的问题就是中缀到后缀的转化。
【5+4*6/2+3+(4*5)/5】->【5 4 6 * 2 / + 3 + 4 5 *5 / +】

思路

首先定义两个集合，一个用于存储最后的结果，一个用于存储转换过程中的操作符
从左到右遍历中缀表达式的每个数字和符号
1、若是操作数就直接输出到结果集
2、如果是左括号则压入到栈中
3、如果是右括号，则输出栈中的操作符直到遇到左括号为止
4、如果是其它操作符，则比较当前操作符与栈顶操作符的优先级
4.1 当栈为空时，直压入栈中
4.2 如果当前操作符的优先级大于栈顶操作符的优先级，压入栈
4.3 否则将栈中操作符输出到结果集，直到栈为空或当前操作符的优先级大于栈顶操作符的优先级，最后将当前操作符压入栈
5、将栈中剩余的操作符输出到结果集

package ddd.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.StringTokenizer;

public class Test {
    static Map<String, Integer> map = new HashMap<String, Integer>();
    static {
        map.put("(", 0);
        map.put("+", 1);
        map.put("-", 1);
        map.put("*", 2);
        map.put("/", 2);
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();//后缀表达式结果集
        Stack<String> stack = new Stack<String>();//操作符栈
        String expression = "5+4*6/2+3+(4*5)/5";
        //按照第二个参数中的字符将字符串切割，第三个参数为true时会保留第二个参数中的字符。
        StringTokenizer stringTokenizer = new StringTokenizer(expression, "()+-*/", true);
        String operators = "()+-*/";
        while (stringTokenizer.hasMoreTokens()) {
            String current = stringTokenizer.nextToken().trim();
            if (operators.indexOf(current) >= 0) {//操作符
                if ("(".equals(current)) {//如果是左括号，直接压入栈
                    stack.push(current);
                } else if (")".equals(current)) {//如果是右括号，输出栈中的操作符直到遇到左括号为止。
                    while (!"(".equals(stack.peek())) {
                        list.add(stack.pop());//将栈中的操作符输出到结果集
                    }
                    stack.pop();//将左括号出栈
                } else {//+-*/
                    if (stack.isEmpty()) {//当栈为空时，直压入栈中
                        stack.push(current);
                    } else if (map.get(current) > map.get(stack.peek())) {//如果当前操作符的优先级大于栈顶操作符的优先级，压入栈
                        stack.push(current);
                    } else {//将栈中操作符输出到结果集，直到栈为空或当前操作符的优先级大于栈顶操作符的优先级，最后将当前操作符压入栈
                        while (!stack.isEmpty() && map.get(current) <= map.get(stack.peek())) {
                            list.add(stack.pop());
                        }
                        stack.push(current);
                    }
                }
            } else {//如果是操作数，直接放入结果集
                list.add(current);
            }
        }
        //将栈中剩余的操作符输出到结果集
        while (!stack.isEmpty()) {
            list.add(stack.pop());
        }
        System.out.println(list);
    }   
}