java数据结构

Java数据结构之栈的使用

使用栈的结构，完成一个简单算术表达式的计算：
算法步骤分析：

使用栈完成表达式的计算思路 94/23+6-6+2
1.通过一个index值(索引)，来遍历表达式
2.当遍历的时候，如果发现是一个数字，就直接让其进入到数据栈
3.如果遍历扫描的是一个符号，分为如下情况：
3.1.如果发现当前的符号栈为空，就直接入栈
3.2.如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个
符号，进行运算，将得到的结果入数栈，然后将当前的操作符入符号栈，如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行
5.最后数栈中只有一个数字，就是表达式的结果
注意：我们每次出栈，进栈，并不是把栈中的元素移出栈，而是通过栈的指针top将栈中的元素进行覆盖。
代码如下：

public class StackCalculator {
    public static void main(String[] args) {
        String expression = "9*4/2*3+6-6+2";
        DataStack dataStack = new DataStack(10);//数栈
        DataStack opStack = new DataStack(10);//符号栈
        //用于存放从数栈中的两个数
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int op = 0;
        //用于存放弹出两个数进行运算的结果
        int result = 0;
        while (true){
            char temp = expression.substring(index,index+1).charAt(0);
            if (opStack.isOP(temp)) {//判断是否是一个运算符
                //如果判断是一个字符，再来判断符号栈是否有操作符
                if (opStack.isEmpty()) {
                    //如果发现当前的符号栈为空，就直接入栈
                    opStack.pushStack(temp);
                } else {
                    // 如果符号栈有操作符,就进行比较
                    // 如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个 符号，进行运算，
                    // 将得到的结果入数栈
                    if (opStack.priority(temp) <= opStack.priority(opStack.getTop())) {
                        num1 = dataStack.popStack();
                        num2 = dataStack.popStack();
                        op = opStack.popStack();
                        result = dataStack.calculator(num1, num2, op);
                        dataStack.pushStack(result);
                        opStack.pushStack(temp);
                    } else {
                        //如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
                        opStack.pushStack(temp);
                    }

                }
            } else {//是一个数字
                dataStack.pushStack((temp - 48));
            }
            index++;
            if (index==expression.length()){
                num1 = dataStack.popStack();
                num2 = dataStack.popStack();
                op = opStack.popStack();
                result = dataStack.calculator(num1, num2, op);
                System.out.println(result);
                break;
            }

        }

    }

    static class DataStack {
        private int maxSize;
        private int[] data;
        private int top = -1;

        public DataStack(int maxSize) {
            this.maxSize = maxSize;
            this.data = new int[maxSize];
        }

        private boolean isFull() {
            return top == maxSize - 1;
        }

        private boolean isEmpty() {
            return top == -1;
        }

        private void pushStack(int num) {
            if (isFull()) {
                System.out.println("栈满");
                return;
            }
            data[++top] = num;
        }

        private int popStack() {
            if (isEmpty()) {
                throw new RuntimeException("栈空，无法出栈");
            }
            int value = data[top--];
            return value;
        }

        //获取运算符的优先级，数字越大，优先级越高
        private int priority(int op) {
            if (op == '*' || op == '/') {
                return 1;
            }
            if (op == '+' || op == '-') {
                return 0;
            } else {
                return -1;
            }
        }

        //判断是不是一个运算符
        private boolean isOP(char op) {
            return op == '+' || op == '-' || op == '*' || op == '/';
        }

        //计算方法
        public int calculator(int num1, int num2, int op) {
            int res = 0;
            switch (op) {
                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 getTop() {
            return data[top];
        }
        @Override
        public String toString() {
            return "DataStack{" +
                    "data=" + Arrays.toString(data) +
                    '}';
        }
    }
}

运行结果：