栈实现综合计算器

• 首先实现数组栈的简单方法和属性：
• 方法包括：

        入栈、出栈、判断栈是否为空、判断栈是否已满、数组栈的构造器、遍历栈的方法、定义运算符的优先级、计算的方法

数组栈的代码实现：

package com.Exer2001.java;

public class ArrayStack {
    private int arrSize;
    private int [] arr;
    private int top;

    public ArrayStack(int Size){
        arrSize = Size;
        arr = new int[arrSize];
        top =-1;
    }

    public void hash(int data){

        if(top ==arrSize){
            throw new RuntimeException("栈已满，无法添加数据！");

        }
        top++;
        arr[top]= data;
    }

    public void list(){
        if(top==-1){
            System.out.println("栈为空！！！");
            return;
        }
        for(int i=top;i>-1;i--){
            System.out.printf("stack[%d] = %d\n",i,arr[i]);
        }
    }
    //出栈操作
    public int pop(){
        if(top==-1){
            throw new RuntimeException("栈为空！！！");
        }
        int value = arr[top];
        top--;
        return value;
    }

    public boolean isEmpty(){
        return top==-1;
    }
    //返回运算符的优先级，由自己定义
    public int priority(int oper){
         if(oper=='*'||oper=='/'){
             return 1;
         }else if(oper=='+'||oper=='-'){
             return 0;
         }else{
             return -1;//假定目前只有这四种
         }
    }
    //判断是不是一个运算符
    public boolean isOper(char ch){
        return ch=='*'||ch=='/'||ch=='+'||ch=='-';
    }
    //返回栈顶元素
    public int peak(){
        return arr[top];
    }

    //计算方法！

    public int cal(int num1,int num2,int ch){
        int res = 0;//用于存放运算结果
        switch(ch){

        case '+':
            res = num1+num2;
            break;
        case '-':
            res = num2-num1;
            break;
        case '*':
            res = num1*num2;
            break;
        case '/':
            res = num2/num1;
            break;
            default:
                break;
        }
        return res;
    }


}

接下来就是关于计算器的调用中的注意点：

        

1. 将表达式写出来
2. 创建两个栈，一个数栈，一个符号栈，用于存入表达式中的元素
3. 定义一个index，用于索引表达式中的元素。然后再定义一些属性 int 类型的num1 ,num2 , res ， oper ,char类型的 ch ....用于接收数据
4. 循环进行索引
5. 如果是字符就进字符栈，如果是数就进入数栈
6. 当进入字符栈时，进行判断是否符号栈为空，如果为空直接进栈
7. 如果符号栈不为空就进行比较，如果当前的操作符的优先级 < 或者 = 栈中符号的优先级
8. 那么就需要从栈中pop出两个数，在从符号栈中pop出一个符号进行运算，将运算结果再次进入数栈，然后将操作符号再次进入符号栈
9. 如果当前操作符的优先级 > 栈中符号的优先级，那么就直接入栈
10. 如果在操作6中判断为数，则进入数栈。
11. 但是，如果是多位数进栈就会出现不一样的结果，因此我们需要考虑到多位数进栈的办法
12. 需要向表达式的index的后一位再看如果是符号才能进行入栈操作。因此我们需要定义一个字符串进行拼接多位数
13. 当一切索引结束后，就可以按顺序从栈中进行pop数和符号，进行运算

具体代码如下：

package com.Exer2001.java;
public class Calculator {
    public static void main(String[] args) {
        String expression= "50*5+4-1*6";
        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 = "";
        //1. 通过一个index索引，来遍历表达式
        while(true){
            ch = expression.substring(index,index+1).charAt(0);
            //判断是否是符号
             //如果是符号就进符号栈
            if(operStack.isOper(ch)){
                //再次判断是否符号栈为空，如果为空直接进栈
                //如果符号栈不为空，那么就进行比较，如果当前的操作符的优先级等于或者小于栈中符号的优先级，
                // 那么就需要从栈中pop出两个数，在从符号栈中pop出一个符号进行运算，将运算结果进入数栈，然后将操作符号进入符号栈
                if(!operStack.isEmpty()){
                    if(operStack.priority(ch)<= operStack.priority(operStack.peak())){
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1,num2,oper);
                        numStack.hash(res);
                        operStack.hash(ch);
                    }else{
                        operStack.hash(ch);
                    }
                }else{
                    operStack.hash(ch);
                }
            }//如果不是符号就进数字栈
            else{
                keepNum+= ch;
                if(index==expression.length()-1){
                    numStack.hash(Integer.parseInt(keepNum));
                }else{
                    //在数字栈中需要再次进行扫描，如果该数字的下一位不是符号，而是数字，那么就需要继续进行扫描，他可能就是多位数入栈
                    //需要向表达式的index的后一位再看如果是符号才能进行入栈操作
                    //因此我们需要定义一个字符串进行拼接多位数

                    if(operStack.isOper(expression.substring(index+1,index+2).charAt(0))) {
                        numStack.hash(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 = numStack.cal(num1,num2,oper);
            numStack.hash(res);
        }
        System.out.println("表达式:" + expression+  "=" + numStack.pop());

    }
}

运行结果为：