leetcode算法学习----逆波兰表达式求值（后缀表达式）

下面题目是LeetCode算法：逆波兰表达式求值(java实现)

逆波兰表达式即后缀表达式。

题目：

 有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式、同时支持括号。（假设所有的数字均为整数，不考虑精度问题）

计算工具：

/**
 * 计算工具
 * @author monkjavaer
 * @date 2018/9/13 14:35
 */
public class CalculatorUtil {
    /**
     * 加
     */
    private static final String ADD = "+";
    /**
     * 减
     */
    private static final String SUBTRACT = "-";
    /**
     * 乘
     */
    private static final String MULTIPLICATION = "*";
    /**
     * 除
     */
    private static final String DIVISION = "/";
    /**
     * 左括号
     */
    private static final String LEFT_PARENTHESIS = "(";
    /**
     * 右括号
     */
    private static final String RIGHT_PARENTHESIS = ")";


    /**
     *
     * 提供给外部的计算方法
     *
     * @param expression 后缀表达式
     * @return 计算结果
     */
    public static int calculation(Expression expression) throws Exception {
        List<String> list = getPostfix(expression);
        Stack<Integer> calculationStack = new Stack<>();
        Integer operandRight;
        Integer operandLeft;
        for (String item : list) {
            if (ADD.equals(item)) {
                operandRight  = calculationStack.pop();
                operandLeft = calculationStack.pop();
                calculationStack.push(operandLeft + operandRight);
            } else if (SUBTRACT.equals(item)) {
                operandRight  = calculationStack.pop();
                operandLeft = calculationStack.pop();
                calculationStack.push(operandLeft - operandRight);
            } else if (MULTIPLICATION.equals(item)) {
                operandRight  = calculationStack.pop();
                operandLeft = calculationStack.pop();
                calculationStack.push(operandLeft * operandRight);
            } else if (DIVISION.equals(item)) {
                operandRight  = calculationStack.pop();
                operandLeft = calculationStack.pop();
                calculationStack.push(operandLeft / operandRight);
            } else {
                calculationStack.push(Integer.parseInt(item));
            }
        }

        return calculationStack.pop();
    }

    /**
     * 判断字符为运算符(+,-,*,/)
     *
     * @param c 输入字符
     * @return
     */
    private static boolean isOperator(char c) {

        return ADD.equals(String.valueOf(c)) || SUBTRACT.equals(String.valueOf(c)) ||
                MULTIPLICATION.equals(String.valueOf(c)) || DIVISION.equals(String.valueOf(c));
    }

    /**
     * 返回的是运算符的优先级
     *
     * @param operator
     * @return
     */
    private static int priority(Operator operator) {
        char operatorName = operator.getOperatorName();
        if (ADD.equals(String.valueOf(operatorName)) || SUBTRACT.equals(String.valueOf(operatorName))) {
            return 1;
        } else if (MULTIPLICATION.equals(String.valueOf(operatorName)) || DIVISION.equals(String.valueOf(operatorName))) {
            return 2;
        } else {
            return 0;
        }
    }

    /**
     * 通过表达式获得后缀表达式
     *
     * @param expression
     * @return
     */
    private static List<String> getPostfix(Expression expression) throws Exception {
        /**
         * 操作符栈
         */
        Stack<Operator> operatorStack = new Stack<>();

        /**
         * 存放后缀表达式
         */
        List<String> operandList = new ArrayList<>();

        String expressionStr = expression.getExpressionStr();
        for (int i = 0; i < expressionStr.length(); i++) {
            char oneChar = expressionStr.charAt(i);

            Operator operator = new Operator();
            operator.setOperatorName(oneChar);

            //遇到操作数：直接输出（添加到后缀表达式中）
            if (Character.isDigit(oneChar)) {
                int num = oneChar - '0';
                while (i + 1 < expressionStr.length() && Character.isDigit(expressionStr.charAt(i + 1))) {
                    num = num * 10 + expressionStr.charAt(i + 1) - '0';
                    i++;
                }
                operandList.add(String.valueOf(num));
            } else if (LEFT_PARENTHESIS.equals(String.valueOf(oneChar))) {
                //遇到左括号：将其入栈
                operatorStack.push(operator);
            } else if (RIGHT_PARENTHESIS.equals(String.valueOf(oneChar))) {
                //遇到右括号：执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出。
                while (!LEFT_PARENTHESIS.equals(String.valueOf(operatorStack.peek().getOperatorName()))) {
                    operandList.add(String.valueOf(operatorStack.pop().getOperatorName()));
                }
                //然后弹出左括号
                operatorStack.pop();
            } else if (isOperator(oneChar)) {
                //遇到运算符
                //栈为空时，直接入栈
                if (operatorStack.isEmpty()) {
                    operatorStack.push(operator);
                } else {
                    // 如果读入的操作符为非")"且优先级比栈顶元素的优先级高或一样
                    if (priority(operatorStack.peek()) < priority(operator)) {
                        operatorStack.push(operator);
                    } else if (priority(operatorStack.peek()) >= priority(operator)) {
                        operandList.add(String.valueOf(operatorStack.pop().getOperatorName()));
                        operatorStack.push(operator);
                    }
                }
            }
        }

        //最终将栈中的元素依次出栈。
        while (!operatorStack.isEmpty()) {
            operandList.add(String.valueOf(operatorStack.pop().getOperatorName()));
        }
        System.out.println(operandList);
        return operandList;
    }

}

　　

表达式：

/**
 * 表达式
 *
 * @author monkjavaer
 * @date 2018/9/12 19:42
 */
public class Expression {

    /**
     * 表达式名字
     */
    private String name;

    /**
     * 表达式
     */
    private String expressionStr;

    /**
     * 表达式值
     */
    private int value;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getExpressionStr() {
        return expressionStr;
    }

    public void setExpressionStr(String expressionStr) {
        this.expressionStr = expressionStr;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

}

　　

操作数：

/**
 * 操作数
 * @author monkjavaer
 * @date 2018/9/12 19:43
 */
public class Operand {
    /**
     * 操作数值
     */
    private Integer operandValue;

    public Integer getOperandValue() {
        return operandValue;
    }

    public void setOperandValue(Integer operandValue) {
        this.operandValue = operandValue;
    }
}

　　

运算符：

/**
 * 运算符
 *
 * @author monkjavaer
 * @date 2018/9/12 19:43
 */
public class Operator {
    /**
     * 运算符符号
     */
    private char operatorName;

    public char getOperatorName() {
        return operatorName;
    }

    public void setOperatorName(char operatorName) {
        this.operatorName = operatorName;
    }

}

　　测试：

/**
 * @author monkjavaer
 * @date 2018/9/13 11:49
 */
public class Test {


    public static void main(String[] args) {
        Expression expression = new Expression();
        expression.setExpressionStr("4 +(13 - 5)");
        try {
            System.out.println(CalculatorUtil.calculation(expression));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}