栈实现计算器（多位数运算）

栈实现计算器（多位数运算）

1.简介

利用栈实现对一个形如“700+2*6-4”的表达式的运算

可以实现操作数为多位数的运算

不能识别小括号

java：jdk1.8

只能实现一位数运算（不支持小括号)

2.代码实现

public class calculatorPlus {
    public static void main(String[] args) {
        String expression="700+2*6-4"; //表达式
        StackDemo1 numberStack=new StackDemo1(10); //数栈
        StackDemo1 operStack=new StackDemo1(10); //符栈
        int i=0;
        while (true){
            char ch=expression.charAt(i);
            if(numberStack.isOperator( ch)){
                //是操作符
                if(operStack.isEmpty()){//判断符栈是否为空，为空直接入符栈
                    operStack.push(ch);
                    i++;
                }else { //不为空则要先比较优先级
                    if(operStack.isPriority( ch, (char) operStack.peek())){
                        //优先级高，则直接入栈
                        operStack.push(ch);
                        i++;
                    }else {
                        //优先级低或相等，则要先从数栈中取出两个数，符栈中取出一个操作符进行运算
                        int num1=numberStack.pop();
                        int num2=numberStack.pop();
                        char opertor= (char) operStack.pop();
                        int re=numberStack.operation(num1,num2,opertor);
                        //将运算出来的结果入数栈
                        numberStack.push(re);
                        //将操作符入符栈
                        operStack.push(ch);
                        i++;
                    }
                }
            }else {
                //不是操作符，是操作数，直接入数栈（但要考虑多位数的情况）
                int num=ch-'0';//num为最终入数栈的数，ch是字符型需转换为对应的数字，eg：ch=‘2’需转换为数字2
                while (true){
                    i++;  //已经将expression中i的位置放入了num中，考虑下一个字符是否为数字
                    if(i>=expression.length()||operStack.isOperator(expression.charAt(i))) { //如果不为数字则直接退出循环，同时注意i的取值要小于expression的长度
                        break;                                                               // ！！if里面的表达式不能交换位置，否则会越界！！
                    }
                    char ch1=expression.charAt(i);  //取出位置为i的字符
                    num=num*10+(ch1-'0');  //将相连的数字组合在一起成为数字
                }
                numberStack.push(num);
            }
            if(i>=expression.length()){
                break;
            }
        }
        //将表达式全部入栈后，按照顺序进行运算
        while (true){
            if(operStack.isEmpty()){ //符栈为空，则表示运算已经完成了
                break;
            }
            int num1=numberStack.pop();
            int num2=numberStack.pop();
            char opertor= (char) operStack.pop();
            int re=numberStack.operation(num1,num2,opertor);
            numberStack.push(re);
        }
        //最后运算完毕，数栈里的只有一个数，这个数就是最后的运算结果
        int re=numberStack.pop();
        System.out.println(expression+"="+re);
    }
}

class StackDemo1{
    int MaxSize; //栈最大长度
    private int top=-1; //栈顶
    private int[] stack; //数组模拟栈
    public StackDemo1(int MaxSize){
        this.MaxSize=MaxSize;
        stack=new int[MaxSize];
    }

    //判断是否为满
    public Boolean isFull(){
        return top==MaxSize-1;
    }
    //判断是否为空
    public Boolean isEmpty(){
        return top==-1;
    }
    //判断是否是操作符
    public Boolean isOperator(char ch){
        return ch == '+' || ch == '-' || ch == '*' || ch == '/';
    }
    //判断优先级，优先级高的返回值大
    public int priority(char ch){
        if(ch == '-' || ch == '+'){
            return 0;
        }if(ch == '*' || ch == '/'){
            return 1;
        }else {
            throw new RuntimeException("暂不支持其他操作符");
        }
    }
    //进行运算
    public int operation(int num1,int num2,char oprator){
        switch (oprator){
            case '+':return num1+num2;
            case '-':return num2-num1;
            case '*':return num1*num2;
            case '/': if(num1==0){
                throw new RuntimeException("被除数不能为0");
            }else {
                return num2/num1;
            }
            default:throw new RuntimeException("操作数有误");
        }
    }
    //判断优先级的大小
    public Boolean isPriority(char ch1,char ch2){
        return priority(ch1)>priority(ch2);
    }
    //入栈
    public void push(int value){
        if(isFull()){
            System.out.println("栈已满！！！");
        }else {
            top++;
            stack[top]=value;
        }
    }
    //出栈
    public int pop(){
        if(isEmpty()){
            throw new RuntimeException("栈已空！！！");
        }
        int re=stack[top];
        top--;
        return re;
    }
    //返回栈顶的数据
    public int peek(){
        return stack[top];
    }
}

3.运行结果

700+2*6-4=708