[043] 使用栈实现综合计算器（中缀）

1、实现思路

• 创建两个栈：数据栈（numStack）和符号栈（operStack）；
• 通过index索引来遍历表达式；
• 如果扫描到的是数字，就直接入栈。不能扫描到一个数就立刻入栈，因为它可能是多位数。需向expression表达式的index后看一位，如果是数就继续后移扫描，直到扫到符号才入栈。
• 如果扫描到的是操作符，则需要分情况考虑；
• 如果发现当前的符号栈为空，就直接入栈；
• 如果符号栈有操作符，就进行比较：① 如果当前操作符的优先级小于等于栈顶操作符，就从数据栈中pop出两个数据，从符号栈中pop出一个符号，运算后将其结果放入数据栈，最后将当前操作符放入符号栈；② 如果当前操作符的优先级大于栈顶操作符，就直接放入符号栈；
• 当表达式扫描完毕，就顺序的从数据栈和符号栈中pop出相应的数据和操作符并运算；
• 最后数据栈中只有一个数字，就是表达式的计算结果。

2、Java代码

package DataStructures.Stack;

/**
 * @author yhx
 * @date 2020/09/18
 */
public class Calculator {
    public static void main(String[] args) {
        String expression = "30+3*6-2";
        //创建两个栈，一个数栈，一个符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);

        //定义需要的变量
        //索引
        int index = 0;
        //数、操作符、运算结果
        int num1, num2, oper, res;
        //扫描缓存
        char ch;
        //用于多位数字的拼接
        String keepNum = "";

        //循环扫描expression每一个字符
        do {
            //依次得到expression的每个字符
            ch = expression.substring(index, index + 1).charAt(0);

            //判断ch是数据还是操作符
            //如果是符号
            if (operStack.isOper(ch)) {
                //判断当前的符号栈是否为空
                if (!operStack.isEmpty()) {
                    //如果不为空，需对数据处理
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        //将运算结果存到数据栈
                        numStack.push(res);
                    }
                }
                //将当前操作符存到符号栈
                operStack.push(ch);
            }

            //如果是数字，则入数据栈
            else {
                //处理多位数，如果ch已经是expression的最后一位，就直接入栈，无需再向后扫描，否则会越界
                keepNum += ch;
                if (index == expression.length() - 1) {
                    //Integer.parseInt(String)的作用就是将String字符类型数据转换为Integer整型数据
                    numStack.push(Integer.parseInt(keepNum));
                } else {
                    final int INDEX1 = index + 1;
                    final int INDEX2 = index + 2;
                    //判断index后面是否是符号
                    if (operStack.isOper(expression.substring(INDEX1, INDEX2).charAt(0))) {
                        //如果后一位是操作符，则将keepNum入栈
                        numStack.push(Integer.parseInt(keepNum));
                        //入栈后要将keepNum清空
                        keepNum = "";
                    }
                }
            }

            //让index+1，并判断是否扫描到expression的最后
            index++;
        } while (index < expression.length());

        //扫描完毕后，符号栈中只存在最低优先级的加和减，只需pop字符和数字运算即可
        while (!operStack.isEmpty()) {
            //如果符号栈为空，则计算完成，数据栈存在最后一个数据，即运算结果
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);

            numStack.push(res);
        }
        //数据栈存在最后一个数据，即运算结果
        int res2 = numStack.pop();
        System.out.printf("表达式%s = %d", expression, res2);
    }
}

/**
 * 栈类，存放数据或符号，并含有一些操作相关的方法函数
 */
class ArrayStack2 {
    private final int maxSize;
    private final int[] stack;
    private int top = -1;

    /**
     * 定义加减乘除符号的常量
     */
    private final char MULTI;
    private final char DIVI;
    private final char ADD;
    private final char SUB;

    /**
     * @param maxSize 栈的最大尺寸
     */
    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        //数组模拟栈，数据就存在该数组中
        stack = new int[this.maxSize];
        MULTI = '*';
        DIVI = '/';
        ADD = '+';
        SUB = '-';
    }

    /**
     * 栈满
     *
     * @return 是否栈满
     */
    public boolean isFull() {
        //当数组顶位标记达到数组最大尺寸，即栈满
        return top == maxSize - 1;
    }

    /**
     * 栈空
     *
     * @return 栈是否为空
     */
    public boolean isEmpty() {
        //当数组顶位值等于默认值-1，即栈空
        return top == -1;
    }

    /**
     * 入栈
     *
     * @param value 要存入的数据
     */
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    /**
     * 出栈：将栈顶的数据返回
     *
     * @return 栈顶数据
     */
    public int pop() {
        if (isEmpty()) {
            //抛出异常，同时返回
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    /**
     * @return 查看栈顶的值，但不是pop
     */
    public int peek() {
        return stack[top];
    }

    /**
     * 返回运算符的优先级
     *
     * @param oper java中int和char可以混用，oper代表传入的数据或者操作符
     * @return 数字越大优先级越高
     */
    public int priority(int oper) {
        if (oper == MULTI || oper == DIVI) {
            return 1;
        } else if (oper == ADD || oper == SUB) {
            return 0;
        } else {
            //假定目前的表达式只有加减乘除
            return -1;
        }
    }

    /**
     * 判断要处理的对象是数字还是运算符
     *
     * @param val 对象
     * @return 1是运算符，0是数字
     */
    public boolean isOper(char val) {
        return val == MULTI || val == DIVI || val == ADD || val == SUB;
    }

    /**
     * 计算方法
     *
     * @param num1 加数/减数/因数/除数
     * @param num2 加数/被减数/因数/被除数
     * @param oper 操作符
     * @return 返回运算后的结果
     */
    public int cal(int num1, int num2, int oper) {
        int res = 0;
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }
}

3、运行结果

表达式30+3*6-2 = 46