中缀表达式实现简单计算器

中缀表达式实现简单计算器

思路分析

1.定义两个栈，一个是数栈，另外是一个符号栈
2.设置优先级别的判断，乘除优先级要大于加减优先级
3.定义一个函数，处理两个操作数和一个运算符的运算符的运算结果
4.逐个扫描输入的中缀表达式，如果是数字就入数栈，如果是运算符的话就考虑其与符号栈顶的运算符的优先级谁的比较高，如果是运算符优先级高于栈顶的话，符号直接入栈，否则，取符号栈栈顶元素出栈与数栈出栈的两个数做运算，结果存入数栈，之后再把运算符入栈。
5.如此往复直到，直到扫描完整个字符串
6.最后要改进的是要注意数字的连续性，设置一个字符串keepnum来获取连续的数字，但是要注意的是获取到数字后字符串要清空，除此之外还要注意数组的越界问题。

代码实现

Calculator.java

package stack;

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String expression;//表达式
        System.out.println("请输入要计算的表达式:");
        expression=in.nextLine();
        in.close();
        //创建两个栈一个数字栈另外一个是符号栈
        ArrayStack numStack=new ArrayStack(10);
        ArrayStack operStack=new ArrayStack(10);
        
        //定义相关的变量
        int index=0;//用于扫描
        int num1=0;
        int num2=0;
        int oper=0;
        int res=0;
        char ch=' ';//每次扫描将char保存到ch
        String keepnum="";//用于拼接多位数的
        while(true) {
            //依次得到expression的每一个字符串
            ch=expression.substring(index, index+1).charAt(0);
            //判断
            if(operStack.isOper(ch)) {//如果是运算符
                if(!operStack.isEmpty()) {//如果字符栈不为空
                    if(operStack.priority(ch)<=operStack.priority(operStack.peek())) {
                        num1=numStack.pop();
                        num2=numStack.pop();
                        oper=operStack.pop();
                        res=numStack.cal(num1, num2, oper);
                        //把运算的结果放数栈
                        operStack.push(ch);
                        numStack.push(res);
                    }else {
                        operStack.push(ch);
                    }
                }else {//如果字符栈为空直接就入栈
                    operStack.push(ch);
                }
            }else {//如果是数字直接就入数栈
                //numStack.push(ch-48);//字符串转数字     
                //当处理多位数的时候，不可以发现一个数立即就入栈可能是多位数字
                //在处理数的时候，需要向expression后面，向这一位就继续扫描，如果是符号就入栈
                //定义一个字符串变量用于拼接
                keepnum+=ch;
                
                //如果已经是expression的最后一位就直接入栈不需要再进行判断
                if(index==expression.length()-1) {
                    numStack.push(Integer.parseInt(keepnum));
                }else {
                    if(operStack.isOper(expression.substring(index+1, index+2).charAt(0))) {
                        //如果后一位是操作符就入栈
                        numStack.push(Integer.parseInt(keepnum));
                        //重要要将累计字符串清空
                        keepnum="";
                    }
                }
                    
            }
            index++;
            if(index>=expression.length()) {
                break;
            }
                
        }
        //当表达式符号栈为空，则计算到最后的结果
        //数栈中只有一个结果
        while(true) {
            if(operStack.isEmpty()) {
                break;
            }
            num1=numStack.pop();
            num2=numStack.pop();
            oper=operStack.pop();
            res=operStack.cal(num1, num2, oper);
            numStack.push(res);
        }
        
        System.out.printf("表达式%s=%d\n",expression,numStack.pop());
        
        
    }
}

ArrayStack.java

package stack;

public class ArrayStack {
    private int maxSize;//最大值
    private int[] stack;//栈
    private int top=-1;//栈顶
    
    //构造器
    public ArrayStack(int maxSize) {
        this.maxSize=maxSize;
        stack=new int[this.maxSize];
    }
    
    //栈满
    public boolean isFull() {
        return top==maxSize-1;
    }
    
    //栈空    
    public boolean isEmpty() {
        return top==-1;
    }
    
    //入栈-push
    public void push(int value) {
        //先判断是否栈满了
        if(isFull()) {
            System.out.println("栈已经满了~");
            return;
        }else {
            top++;
            stack[top]=value;
        }
    }
    
    //出栈-pop
    public int pop() {
        if(isEmpty()) {
            throw new RuntimeException("栈已经空了~");
        }
        int value=stack[top];
        top--;
        return value;
    }
    
    //遍历栈
    
    public void list() {
        if(isEmpty()) {
            System.out.println("栈空，没有数据~");
        }
        for(int i=top;i>=0;i--) {
            System.out.printf("stack[%d]=%d\n",i,stack[i]);
        }
    }
    
    //返回运算符的优先级
    public int priority(int oper) {
        if(oper=='*'||oper=='/') {
            return 1;
        }else if(oper=='+'||oper=='-') {
            return 0;
        }else {
            return -1;//表达式仅仅包含+-*/
        }
    }
    
    //判断是不是一个运算符
    public boolean isOper(char val) {
        return val=='+'||val=='-'||val=='*'||val=='/';
    }
    
    //计算方法
    public int cal(int num1,int num2,int oper) {
        int res=0;
        switch (oper) {
        case '+':
            res=num1+num2;
            break;
        case '-':
            res=num2-num1;
            break;
        case '*':
            res=num1*num2;
            break;
        case '/':
            res=num2/num1;
            break;
        default:
            break;
        }
        return res;
    }
    
    public int peek() {
        return stack[top];
    }
    
}