我的Java数据结构学习--5.1----栈（中缀表达式）

 

package Demo1.stackArray;

//计算机栈实现
public class calculatorStack {
    public static void main(String[] args) {
        calculatorStack calculatorStack = new calculatorStack();

        String test = "7000+20*6*10-4*3*100";
        ArrayStack numberStack = new ArrayStack(10);//数字
        //字符
        ArrayStack operStack = new ArrayStack(10);
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int result = 0;
        char ch = ' ';
        String keepNumber = "";
        while (true) {
            //第一次得到表达式的每一个字符
            ch = test.substring(index, index + 1).charAt(0);
            //判断ch是什么，做出什么处理
            if (calculatorStack.isOper(ch)) {
                //判断栈空
                if (!operStack.stackIsEmpty()) {

                    if (calculatorStack.priority(ch) <= calculatorStack.priority(operStack.peek())) {
                        num1 = numberStack.pop();
                        num2 = numberStack.pop();
                        oper = operStack.pop();
                        result = calculatorStack.cal(num1, num2, oper);
                        //把结果压栈
                        numberStack.push(result);
                        operStack.push(ch);
                    } else {
                        //优先级
                        operStack.push(ch);

                    }
                } else {
                    operStack.push(ch);
                }
            } else {
                //处理多位数时，不能发现一个数就立即入栈（70  ！= 7  0）
                // numberStack.push(ch-48);//ASCII  0 ---48
                //所以一定要扫描到符号为止。
                keepNumber += ch;
                //如果是最后一位
                if (index == test.length() - 1) {
                    numberStack.push(Integer.parseInt(keepNumber));
                } else {
                    //判断下一位是不是数字，如果是数字，就继续扫描
                    if (calculatorStack.isOper(test.substring(index+1, index + 2).charAt(0))) {
                        //后一位是操作符，则入栈
                        numberStack.push(Integer.parseInt(keepNumber));
                        //重要
                        keepNumber = "";//清空
                    }
                }

            }
            index++;
            //判断是否扫描到最后
            if (index >= test.length()) {
                break;
            }
        }

        //最后的结果
        while (true) {
            //如果符号栈为空，则计算到最后的结果，则数栈中只有一个结果
            if (operStack.stackIsEmpty()) {
                break;
            }
            num1 = numberStack.pop();
            num2 = numberStack.pop();
            oper = operStack.pop();
            result = calculatorStack.cal(num1, num2, oper);
            //把结果压栈
            numberStack.push(result);
            // operStack.push(ch);
        }
        System.out.println("表达式：" + test + "   ：---->结果：" + numberStack.pop());

    }

    //字符优先级判断（使用数字表示优先级，优先级越高，数字越大）
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;
        }
    }

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

    //计算方法
    public int cal(int num1, int num2, int oper) {

        int result = 0;
        switch (oper) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num2 - num1;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                result = num2 / num1;
                break;
            default:
                System.out.println("无效");
                break;
        }
        return result;
    }

}

表达式：7000+20*6*10-4*3*100   ：---->结果：7000