计算器

利用栈结构实现的一个简易计算器

代码实现

  1. /**
  2.  * @author laoduan
  3.  * @create 2020-04-11-17:58
  4.  */
  5. public class Calculator {
  6.     public static void main(String[] args) {
  8.         String expressinon = "3+2*6-2";
  10.         Arraystack2 numStack = new Arraystack2(10);
  11.         Arraystack2 operStack = new Arraystack2(10);
  14.         int index=0;//用于扫描
  15.         int num1=0;
  16.         int num2=0;
  17.         int oper=0;
  18.         int res=0;
  19.         char ch = ' ';//将每次扫描得到的char保存到ch
  21.         while (true){
  22.             ch = expressinon.substring(index,index+1).charAt(0);
  24.             if(operStack.isOper(ch)){
  25.                 if(!operStack.isEmpty()){
  26.                     //不空则判断优先级
  27.                     //如果优先级小于或等于栈中的操作符，就从数栈pop两个数
  28.                     //从符合惨pop一个符合进行运算，将得到的结果入数栈，将当前操作符入符栈
  29.                     if(operStack.priority(ch)<=operStack.priority(operStack.peek())){
  30.                         num1=numStack.pop();
  31.                         num2=numStack.pop();
  32.                         oper=operStack.pop();
  33.                         res=numStack.cal(num1,num2,oper);
  34.                         //把运算的结果入数栈
  35.                         numStack.push(res);
  36.                         //当前的操作入符号栈
  37.                         operStack.push(ch);
  38.                     }
  39.                     else {
  40.                         //当前的操作符优先级大于栈中的操作符，直接入符号栈
  41.                         operStack.push(ch);
  42.                     }
  43.                 }else{
  44.                     //栈空则入栈
  45.                     operStack.push(ch);
  46.                 }
  47.             }
  48.             else {
  49.                 numStack.push(ch-48);//ASCII表里面'1'正好比1大48
  50.             }
  51.             index++;
  52.             if(index>=expressinon.length()){
  53.                 break;
  54.             }
  55.         }
  57.         while (true){
  58.             if(operStack.isEmpty()){
  59.                 break;
  60.             }
  61.             num1=numStack.pop();
  62.             num2=numStack.pop();
  63.             oper=operStack.pop();
  64.             res=numStack.cal(num1,num2,oper);
  65.             numStack.push(res);
  66.         }
  67.         int Finres = numStack.pop();
  68.         System.out.printf("表达式%s=%d",expressinon,Finres);
  69.     }
  70. }
  73. //
  75. class Arraystack2{
  76.     private int maxSize;//栈的大小
  77.     private int[] stack;//数组
  78.     private int top = -1;
  81.     public Arraystack2(int maxSize){
  82.         this.maxSize=maxSize;
  83.         stack=new int [this.maxSize];
  84.     }
  86.     //增加方法，返回栈顶的值，但不是pop
  87.     public int peek(){
  88.         return stack[top];
  89.     }
  91.     //栈满
  92.     public boolean isFull(){
  93.         return top==maxSize-1;
  94.     }
  95.     //栈空
  96.     public boolean isEmpty(){
  97.         return top==-1;
  98.     }
  99.     //入栈
  100.     public void push(int value){
  101.         if(isFull()){
  102.             System.out.println("栈满，不能入栈");
  103.             return;
  104.         }
  105.         top++;
  106.         stack[top]=value;
  107.     }
  108.     //出栈
  109.     public int pop(){
  110.         if (isEmpty()){
  111.             throw new RuntimeException("栈空");
  112.         }
  113.         top--;
  114.         return stack[top+1];
  115.     }
  116.     //遍历栈
  117.     public void list(){
  118.         if (isEmpty()){
  119.             System.out.println("栈空，不能遍历");
  120.         }
  121.         for (int i=top;i>-1;i--){
  122.             System.out.printf("stacl[%d]=%d\n",i,stack[i]);
  123.         }
  124.     }
  127.     //返回运算符的优先级，用数字表示
  128.     //数字越大优先级越高
  129.     public int priority(int oper){
  130.         if(oper=='*'||oper=='/'){
  131.             return 1;
  132.         }else if(oper=='+'||oper=='-'){
  133.             return 0;
  134.         }else{
  135.             return -1;//假定目前表达式只有+  -  *  /
  136.         }
  137.     }
  139.     //判断是不是一个运算符
  140.     public boolean isOper(char val){
  141.         return val=='+'||val=='-'||val=='*'||val=='/';
  142.     }
  143.     //计算方法
  144.     public int cal(int num1,int num2,int oper){
  145.         int res = 0;//res用于存放计算ed结果
  146.         switch (oper){
  147.             case'+':
  148.                 res = num1+num2;
  149.                 break;
  150.             case'-':
  151.                 res = num2-num1;
  152.                 break;
  153.             case'*':
  154.                 res = num1*num2;
  155.                 break;
  156.             case'/':
  157.                 res = num2+num1;
  158.                 break;
  159.                 default:
  160.                     break;
  161.         }
  162.         return res;
  163.     }
  165. }