栈实现简单计算器【java】

1.栈实现简单计算器

仅简单实现+，-，*，/

2.思路:

• 1.通过index值(索引),来遍历我们的表达式
• 2.如果发现index是一个数字，就直接入数栈
• 3.如果发现index是一个符号，就分如下情况解决:
• 3.1如果当前的符号栈为空，就直接入栈
• 3.2如果当前的符号栈有操作符，比较：①如果（当前的操作符的优先级<=栈中的操作符），就需要从栈中pop出两个数，从符号栈中pop出一个符号，进行运算，得到的结果，入数栈，再将当前的操作符入符号栈。②如果(当前的操作符的优先级>栈中的操作符),直接入符号栈。
• 4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号。
• 5.最后数栈中只有一个数，就是表达式的结果。

3..声明栈及其方法

//创建一个栈
class Stack {
    private int maxSize;//栈的大小
    private int[] stack;//数组模拟栈，数据放到该数组
    private int top = -1;//栈顶，初始化为-1

    public Stack(int maxSize) {
        this.maxSize = maxSize;
        //初始化
        stack = new int[this.maxSize];
    }

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

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

    //入栈
    public void push(int value) {
        //判断栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    //出栈
    public int pop() {
        //先判断栈是否空
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //遍历栈,遍历时，从栈顶开始显示数据
    public void list() {
        //判断是否为空
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }
        //从栈顶(top)开始遍历
        for (int i = top; i >= 0; i--) {
            System.out.println("stack[" + i + "]=" + stack[i]);
        }
    }

    /**
     * 返回运算符的优先级，优先级使用数字表示，数字越大优先级越高
     */
    public int priority(int operator) {
        if (operator == '*' || operator == '/') {
            return 1;
        } else if (operator == '+' || operator == '-') {
            return 0;
        } else {
            return -1;//只含有+,-,*,/
        }
    }

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

    /**
     * 计算方法
     */
    public int cal(int num1, int num2, char operator) {
        int rse = 0;//res用于存放计算的结果
        switch (operator) {
            case '+':
                rse = num1 + num2;
                break;
            case '-':
                rse = num2 - num1;
                break;
            case '*':
                rse = num1 * num2;
                break;
            case '/':
                rse = num2 / num1;
                break;
        }
        return rse;
    }

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

}

4.测试栈 

public static void main(String[] args) {
        String expression = "800/2*1+1";

        //先创建两个栈，一个数栈，一个符号栈
        Stack numStack = new Stack(10);
        Stack operatorStack = new Stack(10);

        //定义需要的相关变量
        int index = 0;//用于遍历
        int num1 = 0;
        int num2 = 0;
        int operator = 0;//操作符
        int res = 0;//结果
        char ch = ' ';//将每次遍历得到的char保存在ch中
        String keepNum = "";//用于拼接多位数

        //开始遍历
        while (true) {
            //一次的到表达式的每个字符
            ch = expression.substring(index, index + 1).charAt(0);
            //判断ch是数字还是符号
            if (operatorStack.isOperator(ch)) {//是运算符
                //判断当前的符号栈是否为空
                if (!operatorStack.isEmpty()) {
                    //如果当前的符号栈有操作符
                    if (operatorStack.priority(ch) <= operatorStack.priority(operatorStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        operator = operatorStack.pop();
                        res = numStack.cal(num1, num2, (char) operator);
                        //把运算的结果入数栈
                        numStack.push(res);
                        //把当前的操作符入符号栈
                        operatorStack.push(ch);
                    } else {
                        operatorStack.push(ch);
                    }
                } else {
                    //为空直接入栈
                    operatorStack.push(ch);
                }
            } else {//如果是数，直接入数栈
                // numStack.push(ch - 48);
                //1.处理多位数时，不能发现是一个数就立即入栈
                //2.在处理数时，需要向expression表达式的index后在看一位，如果时数,不要立即入栈，如果是符号则入栈
                //3.定义一个字符串变量，用于拼接

                keepNum += ch;
                //如果ch已经是expression的最后一位，就直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else {

                    //判断下一个字符是不是数字，若是数字继续扫描，若是运算符，入栈
                    if (operatorStack.isOperator(expression.substring(index + 1, index + 2).charAt(0))) {
                        //后一位是操作符，入栈
                        numStack.push(Integer.parseInt(keepNum));
                        //!!!keepNum清空
                        keepNum = "";
                    }
                }
            }
            //让index+1，并判断是否扫描到expression最后
            index++;
            if (index >= expression.length()) {
                break;
            }
        }

        //顺序出栈计算
        while (true) {
            //如果符号栈为空则计算最后的结果，数栈中只有一个数字
            if (operatorStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            operator = operatorStack.pop();
            res = numStack.cal(num1, num2, (char) operator);
            numStack.push(res);
        }
        System.out.println("结果:" + numStack.pop());
    }