8、栈-利用栈实现简单的计算器

来源：https://www.bilibili.com/video/BV1B4411H76f?p=33

一、思路

1、拿到一个表达式，当前默认只包含 加减乘除 。利用一个index参数遍历整个表达式，得到每一个数值和运算符。

2、设定两个栈，一个是存储数据的栈【数据栈】，另一个用来存储符号【符号栈】

3、如果当前遍历表达式得到的是一个数据，直接入【数据栈】

4、如果当前遍历表达式得到的是一个符号，分析一下【符号栈】的情况

　　4.1、【符号栈】为空，直接入栈

　　4.2、【符号栈】有操作符，比较当前符号与【符号栈】顶部符号的优先级，当前符号优先级比较低时，从【数据栈】pop两个数据，从【符号栈】pop一个符号，进行运算，得到的结果加入到【数据栈】，之后将当前遍历到的符号加入到【符号栈】。

　　4.3、当前遍历到的符号优先级比较高时，当前符号直接入【符号栈】

5、扫描完成，顺序从【数据栈】和【符号栈】pop出内容进行运算，得到结果。

二、实现

1、首先要在原有的数组模拟栈的类中加入一个数据计算的方法。注意：出栈是先入的后出，所以减法和除法要num2在前num1在后。

    /**
     * 计算
     * @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;
            case '/':
                res = num2 / num1;
        }
        return res;
    }

测试

        System.out.println(numStack.cal(1, 2, '+'));
        System.out.println(numStack.cal(1, 2, '-'));
        System.out.println(numStack.cal(1, 2, '*'));
        System.out.println(numStack.cal(1, 2, '/'));

结果

3
1
2
2

这里犯了一个错误，开始执行的时候结果错才发现的，漏掉了break，要记住

            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;

2、因为需要比较符号的优先级，而且当遍历到的计算符号优先级高时直接入栈，所以之前的符号不能出栈，只能获取，需要一个获取栈顶内容的方法，还需要一个获取符号优先级的方法

    //获取栈顶的元素
    public int peek(){
        return arr[top];
    }

    //获取当前符号的优先级，返回值越大优先级越高
    public int properties(int oper){
        if(oper == '+' || oper == '-'){
            return 1;
        }else if (oper == '*' || oper == '/'){
            return 2;
        }else {
            return -1;//没有这个符号
        }
    }

3、遍历表达式的时候，还需要一个判断当前是数据还是计算符号的方法，因为不能保证这个数据是几位的。

    public boolean isOper(int val){
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

4、在主程序进行计算

    public static void main(String[] args) {
        ArrayStack2 numStack = new ArrayStack2(10);//数据栈
        ArrayStack2 operStack = new ArrayStack2(10);//符号栈
        String expression = "30+2*6-2";//表达式

        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        char ch = ' ';//从表达式扫描出的内容
        String keepNum = "";//如果是多位数，用于拼接

        int res = 0;

        while (true){
            //取出位于index的内容
            ch = expression.substring(index,index + 1).charAt(0);

            if(operStack.isOper(ch)){
                //如果是一个符号的话
                if(operStack.isEmpty()){
                    //如果【符号栈】为空，符号入栈
                    operStack.push(ch);
                }else {
                    //【符号栈】不为空，看下优先级
                    if(operStack.properties(ch) > operStack.properties(operStack.peek())){
                        //当前的符号优先级大于【符号栈】顶部符号的优先级，直接入栈
                        operStack.push(ch);
                    }else {
                        //当前的符号优先级小于等于【符号栈】顶部符号的优先级
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1,num2,oper);
                        numStack.push(res);
                        operStack.push(ch);
                    }
                }
            }else {
                //如果是一个数据的话，看一下，下一个是不是还是数据
                keepNum += ch;//先把当前的数据加入到keepNum
                if(index == expression.length() - 1){
                    //已经走到最后一个位置了，下面没有东西了
                    numStack.push(Integer.parseInt(keepNum));
                }else {
                    if (operStack.isOper(expression.substring(index + 1,index + 2).charAt(0))){
                        //下面是一个符号，需要把当前的数据直接加入栈，然后清空keepNum
                        numStack.push(Integer.parseInt(keepNum));
                        keepNum = "";
                    }
                }
            }
            //保证循环运行下去
            index++;
            //循环结束的条件,index从0开始，等于就相当于没有内容了
            if (index >= expression.length()){
                break;
            }
        }

        //全部入栈之后，将栈内的元素依次计算
        while (true){
            if (operStack.isEmpty()){
                break;
            }else {
                num1 = numStack.pop();
                num2 = numStack.pop();
                oper = operStack.pop();
                res = numStack.cal(num1,num2,oper);
                numStack.push(res);
            }
        }
        System.out.println("计算结果为："+res);


    }

结果

计算结果为：40