栈实现运算器（只能实现个位数的运算）

栈实现运算器（只能实现个位数的运算）

1.简介

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

只能实现操作数为一位数的运算

不能识别小括号

java：jdk1.8

支持多位数（不支持小括号)

2.源代码

public class calculator {
    public static void main(String[] args) {
        String expression="7+2*6-4"; //表达式
      StackDemo numberStack=new StackDemo(10); //数栈
      StackDemo operStack=new StackDemo(10); //符栈
      int i=0;
      while (true){
          char ch=expression.charAt(i);
          if(numberStack.isOperator(ch)){
              //是操作符
              if(operStack.isEmpty()){//判断符栈是否为空，为空直接入符栈
                  operStack.push(ch);
              }else { //不为空则要先比较优先级
                  if(operStack.isPriority(ch, (char) operStack.peek())){
                      //优先级高，则直接入栈
                      operStack.push(ch);
                  }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);
                  }
              }
          }else {
              //不是操作符，是操作数，直接如数栈
              numberStack.push(ch-'0');//ch是字符型需转换为对应的数字
                                             //eg：ch=‘2’需转换为数字2
          }
          i++;
          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 StackDemo{
    int MaxSize; //栈最大长度
    private int top=-1; //栈顶
    private int[] stack; //数组模拟栈
    public StackDemo(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.运行结果

7+2*6-4=15