数据结构栈的应用--使用栈计算算数表达式

代码

package Compute;

public class ArrayStack {
    /*
    * 栈的大小
    * */
    private int maxStack;

    /*
    * 使用数组模拟栈
    * */
    private int[] stack;

    /*
    * 表示栈顶位置，默认时栈顶指针为-1
    * 栈顶指针指向栈顶元素位置
    * */
    private int top = -1;

    /*
    * 栈的构造方法，传入参数规定栈的大小
    * */
    public ArrayStack(int maxStack) {
        this.maxStack = maxStack;
        stack = new int[maxStack];
    }

    //栈的相关方法有：出栈，入栈，判空，判满

    //判满
    public boolean isFUll(){
        return this.top == this.maxStack-1;
    }

    //判空
    public  boolean isEmpty(){
        return this.top == -1;
    }


    //入栈
    public void push(int var){
        if (isFUll()){
            throw new RuntimeException("栈已经满了");
        }
        stack[++top] = var;
    }

    //出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈是空的");
        }
        return stack[top--];
    }

    //查看栈中所有的元素
    public void list(){
        if (isEmpty()){
            throw new RuntimeException("栈是空的");
        }
        for (int value:stack
             ) {
            System.out.println(value);
        }
    }

    //获取栈中元素的个数
    public int getLength(){
        return this.top+1;
    }

    /*
    * 获取栈的容量
    * */
    public int stackLength(){
        return this.stack.length;
    }

    /*
    * 获取栈顶数据
    * */
    public int getTop(){
        return this.stack[top];
    }

    /*
     * 判断是否是一个字符
     * */
    public boolean isOper(int c){//这里使用了强制类型转换，如果传入的是char类型会转换为int类型，并不会损失精度。
        return c == '*' || c == '/' || c == '+' || c == '-';
    }

    /*
    * 判断运算符的优先级
    * 使用数字表示运算符的优先级大小
    * */
    public int priority(int oper){
        if (oper=='*'||oper=='/'){
            return 1;
        }else if (oper=='+'||oper=='-'){
            return 0;
        }else{
            return -1;
        }
    }

    /*
    * 计算方法
    * */
    public int calculate(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:
                break;
        }
        return result;
    }
}

```cpp
package Compute;

public class Test {
    public static void main(String[] args) {
        ArrayStack numStack = new ArrayStack(10);
        ArrayStack operStack = new ArrayStack(10);
        StringBuilder builder = new StringBuilder();
        String str = "33+5-6-2+9+3";
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            //判断字符是否是运算符
            if (operStack.isOper(c)){
                //判断此时运算符栈是否是一个空栈
                if (operStack.isEmpty()){
                    //空栈直接入栈
                    operStack.push(c);
                }else{
                    //运算符栈不是空栈需要跟运算符栈的栈顶运算符
                    // 比较优先级的大小
                    if (operStack.priority(operStack.getTop())<operStack.priority(c)){
                        //优先级大于则运算符直接入栈
                        operStack.push(c);
                    }else {
                        //优先级小于或等于从数字栈中出栈两个数字，运算符栈出栈一个运算符进行运算，运算结果重新入栈
                        int num1 = numStack.pop();
                        int num2 = numStack.pop();
                        int result = numStack.calculate(num1,num2,operStack.pop());
                        numStack.push(result);
                        operStack.push(c);
                    }
                }
            }else{//不是运算符的情况
                //可能存在一位以上的数字情况
                builder.append(c);

                //判断下一位是字符还是数字以此来判断进一步操作
                if (i==str.length()-1){//如果这一位已经是最后一位了那么必然入栈
                    String s = builder+"";
                    numStack.push(Integer.parseInt(s));
                }else {//如果不是最后一位，判断下一位是否是数字
                    char c1 = str.charAt(i+1);
                    if (numStack.isOper(c1)){//是字符则这个数字已经结束直接入栈即可
                        numStack.push(Integer.parseInt(builder+""));
                        //builder要记得需要清空，不然会影响下一次的判断
                        builder = new StringBuilder();
                    }
                }
            }
        }
        //此时运算符栈中的运算符都是同优先级的，因此只需要不断取数据计算再入栈即可
        while (true){
            if (operStack.isEmpty()){//当运算符栈已经没有运算符时计算就已经结束了
                break;
            }
            int number1 = numStack.pop();
            int number2 = numStack.pop();
            int opertion = operStack.pop();
            int result = numStack.calculate(number1,number2,opertion);
            numStack.push(result);
        }
        System.out.println("结果是："+numStack.pop());
    }
}

注意事项是个人编写代码时认为比较重要的编写心得，仅供参考