逆波兰表达式原理实现

解析原理如下：

(1) 该运算符为左括号"("，则直接存入运算符堆栈。
      (2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到操作数堆栈，直到遇到左括号为止，此时抛弃该左括号。
      (3) 该运算符为非括号运算符：
      (a) 若运算符堆栈栈顶的运算符为左括号，则直接存入运算符堆栈。
      (b) 若比运算符堆栈栈顶的运算符优先级高，则直接存入运算符堆栈。
      (c) 若比运算符堆栈栈顶的运算符优先级低或相等，则输出栈顶运算符到操作数堆栈，直至运算符栈栈顶运算符低于（不包括等于）该运算符优先级,或为左括号，
           并将当前运算符压入运算符堆栈。

具体实现：

package com.example.admin.myapplication;

import android.os.Build;
import android.support.annotation.RequiresApi;
import android.text.TextUtils;
import android.util.Log;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

/**
 * Created by admin on 2017/11/8.
 * 逆波兰算法实现
 * 仅支持 + - * /
 */

public class NBLArithmetic {
    private enum Operator {
        ADD("+", 1),
        SUBJECT("-", 1),
        RIDE("*", 2),
        DIVIDE("/", 2),
        BRACKET_L("(", 0),
        BRACKET_R(")", 0),;

        Operator(String value, int weight) {
            this.value = value;
            this.weight = weight;
        }

        String value;
        int weight;

        public String getValue() {
            return value;
        }

        public int getWeight() {
            return weight;
        }

        static Operator fromValue(String value) {
            Operator[] values = values();
            for (Operator val : values) {
                if (value.equals(val.getValue())) {
                    return val;
                }
            }
            return null;

        }

    }

    /**
     * 运算符栈
     */
    private Stack<Operator> operatorStack;
    /**
     * 操作数栈
     */
    private Stack<Integer> operandStack;
    /**
     * 临时存储区，存放逆波兰运算中间结果
     */
    private LinkedList<String> cacheQueue;

    @RequiresApi(api = Build.VERSION_CODES.GINGERBREAD)
    public NBLArithmetic() {
        operatorStack = new Stack<>();
        operandStack = new Stack<>();
        cacheQueue = new LinkedList<>();
    }

    /**
     * 计算结果
     *
     * @param operation
     */
    public void opera(String operation) {
        List<String> operas = getArrayFormOperation(operation);
        for (String opera : operas) {
            if (TextUtils.isDigitsOnly(opera)) {
                cacheQueue.add(opera);
            } else {
                Operator operator = Operator.fromValue(opera);
                Operator lastOperator = operatorStack.empty() ? null : operatorStack.peek();
                if (lastOperator == null || lastOperator == Operator.BRACKET_L || operator == Operator.BRACKET_L) {
                    operatorStack.push(operator);
                } else {
                    switch (operator) {
                        case ADD:
                        case RIDE:
                        case DIVIDE:
                        case SUBJECT:
                            while (lastOperator != null && operator.getWeight() <= lastOperator.getWeight()) {//栈顶优先级大于等于本次操作符
                                cacheQueue.add(operatorStack.pop().getValue());
                                lastOperator = operatorStack.empty() ? null : operatorStack.peek();
                            }
                            operatorStack.push(operator);
                            break;
                        case BRACKET_R:
                            while (lastOperator != null && lastOperator != Operator.BRACKET_L) {
                                cacheQueue.add(operatorStack.pop().getValue());
                                lastOperator = operatorStack.empty() ? null : operatorStack.peek();
                            }
                            operatorStack.pop();
                            break;
                    }
                }
            }
        }
        while (!operatorStack.isEmpty()) {
            cacheQueue.add(operatorStack.pop().getValue());
        }


        //-----------------------开始计算---------------------------------------------------

        while (cacheQueue.size() > 0) {
            String data = cacheQueue.removeFirst();
            if (TextUtils.isDigitsOnly(data)) {
                operandStack.push(Integer.parseInt(data));
            } else {
                Operator operator = Operator.fromValue(data);
                int b = operandStack.pop();
                int a = operandStack.pop();
                switch (operator) {
                    case ADD:
                        operandStack.push(a + b);
                        break;
                    case RIDE:
                        operandStack.push(a * b);
                        break;
                    case DIVIDE:
                        operandStack.push(a / b);
                        break;
                    case SUBJECT:
                        operandStack.push(a - b);
                        break;
                }
            }
        }

        Log.i("NBL", operation + " = " + operandStack.pop());
    }

    /**
     * 解析表达式成array
     *
     * @param operation
     * @return
     */
    private List getArrayFormOperation(String operation) {
        List operaList = new ArrayList();
        char[] chars = operation.toCharArray();
        StringBuffer sb = new StringBuffer();
        for (char a : chars) {
            if (TextUtils.isDigitsOnly(a + "")) {
                sb.append(a + "");
            } else if (".".equals(a + "")) {
                sb.append(a + "");
            } else {
                if (sb.length() > 0) {
                    operaList.add(sb.toString());
                }
                operaList.add(a + "");
                sb.delete(0, sb.length());
            }
        }
        if (sb.length() > 0) {
            operaList.add(sb.toString());
        }
        return operaList;
    }

}

使用很方便：

new NBLArithmetic().opera("3+4*(3-5)*2");
new NBLArithmetic().opera("3+4*(3-5)*2+56");
new NBLArithmetic().opera("3+4*(3-5)*2+56-3*2");
new NBLArithmetic().opera("3+4*(3-5)*2+56-3*2+(2-8)*4");
new NBLArithmetic().opera("56-3+(2-8)*4");
new NBLArithmetic().opera("3+4*(3-5)*2+56-3*2+(2-8)*4");