java栈实现计算器(中缀表达式)

栈的实体类(数组模拟)

/**
 * 用数组实现栈
 */
public class Stack {
    int[] array;//数组模拟栈
    int top=-1;//指针指向栈的最顶端数据
    int maxSize;//栈的最大容量

    public Stack(int maxSize) {
        this.maxSize=maxSize;
        array=new int[maxSize];
    }
    //判断是否为空
    public boolean isEmpety(){
        return top==-1;
    }
    //判断是否满了
    public boolean isFull(){
        return top==maxSize-1;
    }

    //添加方法push
    public void push(int value){
        if (isFull()){
            System.out.println("满了");
            return;
        }
        top++;
        array[top]=value;
    }

    //弹栈方法
    public int  pop(){
        if (isEmpety()){
            throw new RuntimeException("栈是空的");
        }
        int a = array[top];
        top--;
        return  a;
    }

   //查看栈顶符号
    public int select(){
        if (isEmpety()){return 2;}
        return  array[top];
    }
    //判断符号的优先级
    public int youxianji(int c){
        if (c=='+'|c=='-'){
            return 0;
        }else if (c=='*'|c=='/'){
            return 1;
        }else {
            return -1;
        }
    }

    //判断是否是符号
    public boolean isfuhao(int c){
        return c=='+'|c=='-'|c=='*'|c=='/';
    }

    //两个数的加法
    public int cal(int num1,int num2,int a){
        int sum=0;
        switch (a){
            case '+':
                sum= num1+num2;
                break;
            case '-':
                sum= num2-num1;
            break;
            case '*':
                sum= num1*num2;
            break;
            case '/':
                sum= num2/num1;
            break;
        }
        return sum;
    }
}

在基础数组的压栈弹栈方法外,我们又增加了四个方法
方法1:判断是否为符号
方法2:比较两个符号的优先级
方法3:根据符号两个数相加的方法
方法4:查看栈针指向符号,不取出只是查看

计算器实现

public class Calculator {
    public static void main(String[] args) {
      String s="4-2*6-5";//表达式 711*2*2-5+1-5+3-4 = 2834
      Stack nostack=new Stack(10);//数字栈
      Stack fhstack=new Stack(10);//符号栈
        int index=0;//用来扫描字符串
        int fh=0;//存储扫描的符号
        int num1;//存储数字栈中的数字
        int num2;//存储数字栈中的数字
        int sum;//存储数字栈中数字的运算结果
        String abc="";//用来拼接多位数字
        while (true){
            fh = s.substring(index,index+1).charAt(0);//先扫描第一个
            //判断是否为符号
            if (fhstack.isfuhao(fh)){//如果是符号
                //判断符号栈是否为空,空就直接加入,不为空判断符号优先级
                if (fhstack.isEmpety()){//如果为空直接加入
                    fhstack.push(fh);
                }else {//如果不为空,查看栈顶符号,对比优先级
                    if (fhstack.youxianji(fh)<=fhstack.youxianji(fhstack.select())){
                        //如果优先级小于等于符号栈最顶端的符号
                        num1=nostack.pop();//拿出数字栈的元素
                        num2=nostack.pop();//拿出数字栈的元素
                        int f=fhstack.pop();//拿出符号栈的符号
                        sum = nostack.cal(num1,num2,f);//计算结果
                        nostack.push(sum);//将计算结果压入数字栈
                        //此时应该考虑,是不是要再次拿栈针比较下,如果真的优先级高的话直接压栈,否则继续拿出两个数相加
                        if (fhstack.youxianji(fh)<=fhstack.youxianji((char) fhstack.select())){
                            num1=nostack.pop();
                            num2=nostack.pop();
                            char a2= (char) fhstack.pop();
                            sum = nostack.cal(num1,num2, a2);
                            nostack.push(sum);

                        }
                        fhstack.push(fh);//将符号再压入符号栈
                    }else {//如果优先级大于符号栈栈顶元素,直接加入符号栈
                        fhstack.push(fh);
                    }
                }
            }else {
                //如果是数字,判断是不是最后一位,是的话直接而加不是的话继续扫描
                abc+=fh-48;
                if (index+1==s.length()){
                    //说明是最后一位直接加
                    nostack.push(Integer.parseInt(abc));
                }else {
                    //如果不是最后一位,判断后一位是不是符号
                    //如果是数字
                    //如果是数字就要判断下一位,是不是数字
                    int a = s.substring(index+1,index+2).charAt(0);
                    if (fhstack.isfuhao(a)){//如果是符号
                        //是符号就,将数字压入栈内
                        nostack.push(Integer.parseInt(abc));
                        abc="";//压入完成让abc恢复空值
                    }
                }
            }
            index++;//下标后移
            if (index>=s.length()){//扫描完成退出
                break;
            }
        }

        //压栈完成开始计算
        while (true){
            if (fhstack.isEmpety()){
                break;
            }
            num1=nostack.pop();
            num2=nostack.pop();
            int a=fhstack.pop();
            sum=nostack.cal(num1,num2,a);
            nostack.push(sum);
        }
        System.out.println(nostack.pop());
    }
}

伪代码

package com.data.Calculator1;

public class Test {
    public static void main(String[] args) {
       while (true){
           按照下标取
           if (如果是符号){
               if (如果符号栈为空){
                   直接加
               }else {
                   不为空判断优先级
                   if(优先级小于等于){
                       数字栈弹栈两个,符号栈弹栈一个,
                               将运算的值压栈数字栈

                       符号压栈,还需判断优先级
                       if(优先级小于等于){
                           数字栈弹栈两个,符号栈弹栈一个,
                                   将运算的值压栈数字栈
                       }
                       此时才能将符号压栈
                   }else {
                       优先级大于直接压栈
                   }
               }
           }else {如果是数字
                   直接压栈
           }
       }
       while (true){
           压栈都完成了
                   从两个栈取出元素运算
                   每运算一次,再将结果添加到数字栈
                           知道符号栈为空,运算结束
       }
       最后输出数字栈中的最后一个数据,即是运算的结果
    }
}

源码下载

https://download.csdn.net/download/weixin_46705768/13023163