栈综合使用【加减乘除计算器】

代码

public class Main {

    public static void main(String[] args) {

        int result = calExpression("100+2*4-6/3");
        System.out.println(result);
    }

    public static int calExpression(String expression){
        //数栈 符号栈
        ArrayStack numStack = new ArrayStack(20);
        ArrayStack operStack = new ArrayStack(20);
        char oneChar;
        int index = 0;
        int result = 0;
        String realNum = "";

        while (true){
            if (index == expression.length()){
                System.out.println("表达式已全部入栈");
                break;
            }
            oneChar = expression.charAt(index);
            index++;
            System.out.println(index);
            System.out.println("oneChar:"+oneChar);

            //判断是符号还是数字
            if (isOper(oneChar)){
                System.out.println("是符号");
                //如果是符号
                //先看看栈里面是否为空
                if (operStack.isEmpty()){
                    //如果是空，则直接入栈
                    operStack.push(oneChar);
                }else{
                    int operInStack = operStack.pop();//弹出栈的运算符

                    if (priority(oneChar) > priority(operInStack)){
                        //弹出的运算符优先级低，则直接入栈
                        operStack.push(operInStack);
                        operStack.push(oneChar);
                    }else {
                        int num1 = numStack.pop();
                        int num2 = numStack.pop();
                        numStack.push(calculate(num2, num1, operInStack));
                        operStack.push(oneChar);
                    }
                }
            }else {
                //是数字，要判断是不是多位数
                realNum = realNum + oneChar;//这个变量要定在外面

                //如果此oneChar已经是最后一位了 则直接入栈 防止越界
                if (index == expression.length()){
                    numStack.push(Integer.parseInt(realNum));//注意这里看看是否要转成ASCⅡ值，因为这里转成int了 所以就不用再减了
                    realNum = "";//一定要注意清空！！！
                }else {
                    //如果不是最后一位，则往后看一位，看看是不是多位数
                    if (isOper(expression.charAt(index))){
                        //说明是符号,则入栈
                        numStack.push(Integer.parseInt(realNum) );//
                        realNum = "";//一定要注意清空！！！
                    }//如果不是单位数，则先不压栈，等realNum把这个数记全了之后一起压进去
                }

            }
        }

        while (true){
            if (operStack.isEmpty()){
                //符号栈为空，则结果已出
                System.out.println("结果已经出来了");
                break;
            }else {
                int oper = operStack.pop();
                int num1 = numStack.pop();
                int num2 = numStack.pop();
                System.out.println("num1:"+num1);
                System.out.println("num2:"+num2);
                System.out.println("oper:"+oper);
                System.out.println("结果："+calculate(num2, num1, oper));
                numStack.push(calculate(num2, num1, oper));
            }
        }

        result = numStack.pop();
        return result;
    }
    //返回运算符的优先级，这个优先级是程序员自己定的
    public static int priority(int oper){
        if (oper == '*' || oper == '/'){
            return 1;
        }else if (oper == '+' || oper == '-'){
            return 0;
        }else {
            return -1;//异常情况
        }
    }

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

    //计算
    public static int calculate(int num1,int num2,int oper){
        int result = 0;

        //要记住 switch的每一个case都要break
        switch (oper){
            case '+':
                result = num1 + num2;
                System.out.println("result:"+ result);
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                result = num1 / num2;
                break;
            default:
                break;
        }
        System.out.println("result1:"+ result);
        return result;
    }
}
class ArrayStack{
    int maxSize;
    int top;//栈顶
    int[] array;

    ArrayStack(int maxSize){
        this.maxSize = maxSize;
        top = -1;
        array = new int[maxSize];
    }

    //判断栈是否满了
    public boolean isFull(){
        return top == maxSize-1;
    }

    //判断栈是否为空
    public boolean isEmpty(){
        return top == -1;
    }

    //入栈
    public void push(int item){
        if (isFull()){
            System.out.println("栈满了 无法入栈");
            return;
        }
        array[top + 1] = item;
        top++;
    }

    //出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈是空的");
        }

        int value = array[top];
        top--;
        return value;
    }

    //遍历栈
    public void showStack(){
        if (isEmpty()){
            throw new RuntimeException("栈是空的");
        }

        int temp = top;
        for (int i = temp;i >= 0;i--){
            System.out.println(array[i]);
        }
    }
}

结果

1
oneChar:1
2
oneChar:0
3
oneChar:0
4
oneChar:+
是符号
5
oneChar:2
6
oneChar:*
是符号
7
oneChar:4
8
oneChar:-
是符号
result1:8
9
oneChar:6
10
oneChar:/
是符号
11
oneChar:3
表达式已全部入栈
num1:3
num2:6
oper:47
result1:2
结果：2
result1:2
num1:2
num2:8
oper:45
result1:6
结果：6
result1:6
num1:6
num2:100
oper:43
result:106
result1:106
结果：106
result:106
result1:106
结果已经出来了
106

Process finished with exit code 0

需要注意的地方

①思路要清晰

有两个栈，分别是符号栈和数栈

1.通过一个index 值（索引），来遍历我们的表达式
2.如果我们发现是一个数字,就直接入数栈（注意考虑多位数的情况）
3.如果发现扫描到一个符号,就分如下情况

• 3.1 如果发现当前的符号栈为空，就直接入栈
• 3.2 如果符号栈有操作符，就进行比较
  • 3.2.1 如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈（注意，参与运算的是符号栈中的符号，而不是刚从表达式中取到的符号）
  • 3.2.2 如果当前的操作符的优先级大于栈中的操作符,就直接入符号栈

4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号,并计算
5.最后在数栈只有—个数字,就是表达式的结果

②switch的每一个case都需要break

③注意 字符’1’ 在ASCⅡ码表中并不是1，而是49。

④注意 变量的定义是否需要全局，如果是全局的话，是否需要在恰当时机进行清空。