栈实现综合计算器（中缀表达式）

代码实现

package com.springboot.数据结构.stack;

/**
 * @author: 牧羊
 * @Date: 2020/4/29 15:28
 * 栈实现综合计算器（中缀表达式）
 */
public class Calculator {

    public static void main(String[] args) {

        String expression = "7*2*2-5+1-5+3-4";

        //创建两个栈，一个数栈，一个符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);

        //定义需要的相关变量
        int index = 0;//用于扫描
        int num1 = 0;//用于扫描
        int num2 = 0;//用于扫描
        int oper = 0;
        int res = 0;
        char ch; //将每次扫描得到的char保存到ch
        String keepNum = "";//用于拼接多位数

        //开始循环扫描expression
        while (true){
            //一次得到expression的每个字符
            ch = expression.substring(index,index+1).charAt(0);
            //判断ch是什么，然后进行相应的处理
            if(operStack.isOper(ch)){ //如果是运算符
                //判断当前的符号栈是否为空
                if(!operStack.isNull()){
                    //如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就要从栈中pop两个数
                    //再从符号栈中pop出一个符号进行运算，将得到结果，入数栈，然后将当前额操作符入符号栈
                    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{
                        //如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
                        operStack.push(ch);
                    }
                }else{
                    //如果为空，则直接入符号栈
                    operStack.push(ch);

                }
            }else { //如果是数字，就直接入数栈
                //分析思路
                //1：当处理多位数的时候，不能发现一个数就入栈，因为他可能是多位数
                //2：在处理数，需要向expression的表达式index后再看一位，如果是数就进行扫描，如果是符号才入栈
                //3：因为我们需要定义一个变量字符串，用于拼接

                //处理多位数
                keepNum += ch;

                //如果ch已经是expression的最后一位，则直接入栈
                if(index == expression.length() -1){
                    numStack.push(Integer.parseInt(keepNum));
                }else{
                    //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
                    //注意是后一位，不是index++
                    if(operStack.isOper(expression.substring(index + 1,index + 2).charAt(0))){
                        //如果最后一位是运算符，则入栈keepNum = “1”
                        numStack.push(Integer.parseInt(keepNum));
                        keepNum = "";
                    }

                }

            }
            //让index加1，并判断是否扫描到expression最后
            index++;
            if(index >= expression.length()){
                break;
            }
        }

        //当表达式扫描完毕，就顺序的从数栈和符号栈中pop相应的数和符号，并运行
        while (true){
            //如果符号栈，则计算到最后的结果，数栈中还有一个数字（结果）
            if(operStack.isNull()){
                break;
            }

            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1,num2,oper);

            numStack.push(res);
        }

        //将数栈最后的结果push出来就是结果
        int res2 = numStack.pop();
        System.out.println("结果为：" + res2);
    }
}

class ArrayStack2{
    private int maxSize;    //栈的大小
    private int[] stack;    //数组，数组模拟栈，数据放到数组当中
    private int top = -1;        //top表示栈顶

    //构造器
    public ArrayStack2(int maxSize){
            this.maxSize = maxSize;
            stack = new int[maxSize];
    }

    //返回当前栈顶的值，但不是出栈
    public int peek(){
        return stack[top];
    }

    //栈满
    public boolean isFull(){
       return maxSize - 1 == top;
    }

    //栈空
    public boolean isNull(){
        return top == -1;
    }

    //入栈
    public void push(int value){
        //先判断是否栈满
        if(isFull()){
            System.out.println("栈满");
            return;
        }

        top++;
        stack[top] = value;
    }

    //出栈
    public int pop(){
        //先判断栈是否为空
        if(isNull()){
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //遍历
    public void list(){
        if(isNull()){
            System.out.println("栈空");
            return;
        }

        //从栈顶开始遍历
        for(int i = top ; i >= 0 ; i--){
            System.out.println("出栈：" + stack[i]);
        }
    }

    //返回运算符的优先级，优先级程序员来确认，优先使用数字表示
    //数字越大，优先级越高
    public int priority(int oper){
        if(oper == '*' || oper == '/'){
            return 1;
        }else if(oper == '+' || oper == '-') {
           return 0;
        }else{
            return -1;
        }
    }

    //判断不是一个运算符
    public boolean isOper(char val){
        boolean b = val == '+' || val == '-' || val == '*' || val == '/';
        return b;
    }

    //计算方法
    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;
    }
}