09--栈实现综合计算器

• 使用栈完成表达式的计算思路

1、通过一个index值（索引），来遍历我们的表达式

2、如果我们发现是数字，则直接入数栈；如果发现扫描到的是符号，就分一下集中情况：

3.1 ：如果符号栈有操作符，就需要进行比较 -->

         3.1.1 如果当前操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出2个数，在从符号栈中pop出1个符号进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈

         3.1.2 如果当前操作符的优先级大于栈中的操作符，就直接入符号栈

4、当表达式扫描完毕，就顺序地从数栈和符号栈中pop除相应的数和符号，并运行

5、最后在数栈中只有一个数字，就是表达式的结果

验证：3+2*6-2 ==> 13

 

class ArrayStack{
    private int maxSize; //栈中最多的数据个数
    private int[] stack; //数组模拟
    private int top = -1;  //栈顶
    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }
    
    //入栈【先检查栈是否满了】
    public void push(int n) {
        if (top == maxSize - 1) {
            System.out.println("栈满，无法加入数据");
            return;
        }else {
            top++;
            stack[top] = n;
        }
    }
    
    //栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }
    
    //出栈【先检查栈是否空了】
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空，无数据");
        }else {
            return stack[top--];
        }
    }
    
    //展示栈中的数据【先检查栈是否空了】
    public void show() {
        if (isEmpty()) {
            System.out.println("栈空，无数据可以展示");
            return;
        }else {
            for(int i = top;i >= 0; i--) {
                System.out.printf("stack[%d] = %d\n",i,stack[i]);
            }
        }
    }
    
    //返回运算符的优先级【*、/ 比 + 、- 高】<返回的数字越大，优先级越高>
    public int priority(int operator) {
        switch(operator) {
        case '*':
        case '/':
            return 1;
        case '+':
        case '-':
            return 0;
        default:
            return -1;
        }
    }
    
    //判断是否是运算符【假设只有加减乘除】
    public boolean isOperator(int operator){
        return operator == '+' || operator == '-' || operator == '*' || operator == '/';
    }
    
    //根据数栈中弹出来的两个数和符号栈中弹出来的一个符号进行运算
    public int cal(int num1, int num2, int operator) {
        int ret = 0;
        //此处不能在switch内部直接进行return
        switch(operator) {
        case '+':
            ret = num1 + num2;
            break;
        case '-':
            //注意顺序：后弹出来的减去前弹出来的
            ret = num2 - num1; 
            break;
        case '*':
            ret = num1 * num2;
            break;
        case '/':
            ret = num2 / num1; //此处不考虑除数为0的情况
            break;
        default:
            break;
        }
        return ret;
    }
    
    //偷看一下位于符号栈栈顶的符号，并不取出
    public int peek() {
        return stack[top];
    }
    
 }

public class Calculator {

    public static void main(String[] args) {
        //定义表达式
        String expression = "80+12*600-21"; // 7280 - 21 = 7259 
        //创建数栈、符号栈
        ArrayStack numberStack = new ArrayStack(10);
        ArrayStack operatorStack = new ArrayStack(10);
        //定义相关变量
        int index = 0; //索引依次取出表达式中的数和符号
        int num1 = 0;
        int num2 = 0; //num1 和 num2用于接收连续从数栈出栈的两个值
        int operator = 0; //接收从符号栈中参与运算的符号
        int ret = 0; //运算结果
        char ch = ' '; //接收每次扫描到的数据
        String str = "";
        while(index < expression.length()) {
            ch = expression.substring(index, index+1).charAt(0);
            //ch = expression.charAt(index++); //取一个字符等价于本行
            //如果是符号【分两种情况】
            if (operatorStack.isOperator(ch)) {
                //情况1：符号栈为空则直接入符号栈
                if (operatorStack.isEmpty()) {
                    operatorStack.push(ch);
                }else {
                    //情况2：符号栈不为空【在分两种情况】
                    //情况2.1：当前运算符的优先级小于或者等于栈顶运算符的优先级,则从数栈中pop出两个数
                    //从符号栈中pop出一个符号进行运算
                    if (operatorStack.priority(ch) <= operatorStack.priority(operatorStack.peek())) {
                        num1 = numberStack.pop();
                        num2 = numberStack.pop();
                        operator = operatorStack.pop();
                        ret = operatorStack.cal(num1, num2, operator);
                        //将运算的结果入数栈
                        numberStack.push(ret);
                        //把当前运算符入符号栈
                        operatorStack.push(ch);
                    }else{ //情况2.2：当前运算符的优先级大于栈底运算符的优先级，直接入符号栈
                        operatorStack.push(ch);
                    }
                }
            }else {
                //如果是数，则直接入数栈
                //numberStack.push(ch - 48); //注意： 字符'0' --> 48 【只能处理个位数】
                str += ch;
                //此时：如果index是表达始终的最后一位数，将其直接压入到数栈中
                if (index == expression.length() - 1) {
                    numberStack.push(Integer.parseInt(str));
                }
                else {
                    //往后多看一位
                    if (numberStack.isOperator(expression.substring(index+1,index+2).charAt(0))) {
                        //是操作符【入栈】,如果不是操作符则继续拼接 str += ch;
                        numberStack.push(Integer.parseInt(str));
                        str = "";
                    }
                    
                }
            }
            index++; //继续遍历
        }
        //表达式扫描完毕，顺序地从数栈和符号栈中弹出数据和符号进行运算，直到符号栈为空，则最后留在数栈中的数即为最终结果
        while(!operatorStack.isEmpty()) {
            num1 = numberStack.pop();
            num2 = numberStack.pop();
            operator = operatorStack.pop();
            ret = operatorStack.cal(num1, num2, operator);
            //将运算的结果入数栈
            numberStack.push(ret);
        }
        System.out.println("表达式" + expression + "的最终结果是：" + numberStack.pop());
    }
}