小胡博客

栈的实例小测验

用自己手写栈模拟一个计算器(+-*/)

package com.xiaohu.suanfa.stack;

/**
 * @author 小胡哥哥
 * NO BB show your code
 * 自定义一个小型计算器
 */
public class CalculatorStack {

    static class StackManger {
        //数组最大容量
        private int maxSize;
        //栈顶
        private int top = -1;
        private int[] stack;

        private int size;

        public StackManger(int maxSize) {
            this.maxSize = maxSize;

            //定义一个数组
            stack = new int[this.maxSize];
        }

        public StackManger() {

            //没有显示设置容量大小则默认容量为6
            stack = new int[6];
        }

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

        /**
         * 判断栈是否满了
         *
         * @return
         */
        public boolean isFull() {
            return top == stack.length - 1;
        }

        /**
         * 添加
         *
         * @param n
         */
        public void push(int n) {
            if (isFull()) {
                System.out.println("栈已满，无法添加");
                return;
            }
            top++;
            stack[top] = n;
            size++;
        }

        public int pop() {
            if (isEmpty()) {
                System.out.println("栈为空");
                return -1;
            }
            int value = stack[top];
            top--;
            return value;
        }

        public void listShow() {
            if (isEmpty()) {
                return;
            }
            //栈从顶部遍历,从top减一开始遍历
            for (int i = top - 1; i >= 0; i--) {
                System.out.printf("stack[%d]=%d\n", i, stack[i]);
            }
        }

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


        /**
         * 进行运算
         *
         * @param num1
         * @param num2
         * @param operator
         * @return
         */
        private int calc(int num1, int num2, int operator) {
            int res = 0;
            switch (operator) {
                case '+':
                    res = num1 + num2;
                    break;
                case '-':
                    //减法和除法后面的减去前一位，栈是先进后出，加法和乘法没影响
                    res = num2 - num1;
                    break;
                case '*':
                    res = num1 * num2;
                    break;
                case '/':
                    res = num2 / num1;
                    break;
                default:
                    break;
            }
            return res;
        }

        /**
         * 返回运算符优先级 只包含+-* /
         */
        private int priority(int operator) {

            if (operator == '*' || operator == '/') {
                return 1;
            } else if (operator == '+' || operator == '-') {
                return 0;
            } else {
                throw new RuntimeException("运算符有误~~");
            }
        }

        /**
         * 判断是否为运算符
         */
        private boolean isOperator(char value) {
            return value == '+' || value == '-' || value == '*' || value == '/';
        }

        /**
         * 进行运算
         *
         * @param str
         * @param numStack
         * @param operatorStack
         * @return
         */


        private int listStr(String str, StackManger numStack, StackManger operatorStack) {
            char[] charArray = str.toCharArray();
            //主要用来拼接多位数字
            StringBuilder strNum = new StringBuilder();
            for (int index = 0; index < charArray.length; index++) {
                //判断是否为数字
                if (!isOperator(charArray[index])) {
                    strNum.append(charArray[index]);
                    //当index为最后一位的时候，就不需要判断下一位是否是运算符
                    if (index == charArray.length - 1) {
                        // numStack.push(Integer.parseInt(strNum));
                        //数字添加到数字栈中,不能直接存 因为存的不是 1 而是'1' 中间间隔48(或者直接 - '0')
                        numStack.push(charArray[index] - '0');
                    } else {
                        //判断下一位是否是不是数字,是的话继续扫描，是运算符就入栈
                        if (operatorStack.isOperator(charArray[index + 1])) {
                            numStack.push(Integer.parseInt(strNum.toString()));
                            //这里很重要，入栈之后进行清空  strNum = "1" 不清空将会一直往后面拼接
                            strNum = new StringBuilder();

                        }
                    }
                } else {
                    if (operatorStack.isEmpty()) {
                        //如果符号栈为空，直接入栈
                        operatorStack.push(charArray[index]);
                        //代表当前的运算符优先级小于或者等于栈中的运算符
                    } else if (this.priority(charArray[index]) <= operatorStack.priority(operatorStack.peek())) {
                        //不为空并且优先级低，则pop出一个符号和pop出两个数字进行运算
                        int num1 = numStack.pop();
                        int num2 = numStack.pop();
                        int operator = operatorStack.pop();
                        //得到运算结果
                        int res = this.calc(num1, num2, operator);
                        //将运算结果压入数栈中
                        numStack.push(res);
                        //将当前运算符入符号栈
                        operatorStack.push(charArray[index]);
                    } else if (this.priority(charArray[index]) > operatorStack.priority(operatorStack.peek())) {
                        //将运算符直接压栈
                        operatorStack.push(charArray[index]);
                    }
                }
            }

            while (!operatorStack.isEmpty()) {
                //运算到最后符号栈为空
                //当表达式扫描完毕，就顺序的从数栈和符号栈pop进行运算
                int num1 = numStack.pop();
                int num2 = numStack.pop();
                int operator = operatorStack.pop();
                int res = this.calc(num1, num2, operator);
                numStack.push(res);

            }
            //将最后数栈最后的结果 pop出来就是结果
            return numStack.pop();
        }
    }

    public static void main(String[] args) {

        //计算这个表达式等于多少
        String str = "1000+30*4/2";
        //主要存放数字
        StackManger numStack = new StackManger(10);

        //主要存放运算符
        StackManger operatorStack = new StackManger(10);
        StackManger stackManger = new StackManger();
        int res = stackManger.listStr(str, numStack, operatorStack);
        System.out.println("运算的结果为:" + res);

    }
}

赏

×

纯属好玩

扫码打赏，你说多少就多少

打开支付宝扫一扫，即可进行扫码打赏哦