JAVA实现逆波兰转换

在家翻看信息检索的课本，实在太无聊了，还是写代码比较high。

用java实现逆波兰转换之后，感觉对逆波兰转换的步骤记忆更加深刻了，不错，不错~

下面上代码

package com.hicc.lc;

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

import com.hicc.lc.vo.Result;

public class Generator {
    // 获得运算符优先级
    public static int getPriority(String operator) {
        final int plusPriority = 2;
        final int multiplyPriority = 3;
        final int minusPriority = 4;
        final int leftBracketPriority = 1;
        if ("+".equals(operator))
            return plusPriority;
        if ("*".equals(operator))
            return multiplyPriority;
        if ("-".equals(operator))
            return minusPriority;
        if ("(".equals(operator))
            return leftBracketPriority;
        return 0;
    }

    // 比较两运算符优先级
    public static boolean priorThan(String operatorA, String operatorB) {
        return getPriority(operatorA) > getPriority(operatorB);
    }

    public static void main(String args[]) {
        String expression = "(a+b+c)*d*-e+f*g";
//        String expression = "(A+B)*(C+D)+E";
        Map<Integer, String> retrivalWords = new HashMap<Integer, String>();// 检索词表存储区
        Stack<String> operatorList = new Stack<String>();// 算子保留栈
        List<Result> result = new ArrayList<Result>();// 结果保留栈
        expression = expression.concat(".");
        int letterNum = 0;
        for (int i = 0; i < expression.length(); i++) {
            String s = String.valueOf(expression.charAt(i));
            if (s.matches("[a-zA-Z]")) {
                letterNum = letterNum + 1;
            } else {
                if (letterNum > 0) {
                    String retrivalWord = expression
                            .substring(i - letterNum, i);
                    retrivalWords.put(retrivalWords.size() + 1, retrivalWord);
                    result.add(new Result(0, retrivalWord));
                    letterNum = 0;
                }
                if ("(".equals(s)) {
                    operatorList.push("(");
                }
                if ("+*-".contains(s)) {
                    while ((!operatorList.isEmpty())
                            && (!priorThan(s, operatorList.peek()))) {
                        result.add(new Result(1, operatorList.pop()));
                    }
//                    if((!operatorList.isEmpty())
//                            && !s.equals(operatorList.peek()))
                        operatorList.push(s);
                }
                if (")".equals(s)) {
                    while (!operatorList.peek().equals("(")) {
                        result.add(new Result(1, operatorList.pop()));
                    }
                    operatorList.pop();
                }
                if (".".equals(s)) {
                    while (!operatorList.isEmpty()) {
                        result.add(new Result(1, operatorList.pop()));
                    }
                    result.add(new Result(1, "."));
                }

            }
        }
        System.out.print("输出逆波兰表达式:");
        for (int j = 0; j < result.size(); j++) {
            System.out.print(result.get(j).getContent());
        }
        System.out.println();
    }
}

package com.hicc.lc.vo;

public class Result {
    private int charactor;
    private String content;

    public Result(int charactor, String content) {
        this.charactor = charactor;
        this.content = content;
    }

    public int getCharactor() {
        return charactor;
    }

    public String getContent() {
        return content;
    }

    public void setCharactor(int charactor) {
        this.charactor = charactor;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

很久不编程了，各种数据结构都已经记混了，如果有人认为上面的代码有哪里需要改进的欢迎指正.