蓝桥杯——表达式计算

package com.company.Algorithm_training;

import java.util.Scanner;
import java.util.Stack;

/**

• 问题描述
• 输入一个只包含加减乖除和括号的合法表达式，求表达式的值。其中除表示整除。
• 输入格式
• 输入一行，包含一个表达式。
• 输出格式
• 输出这个表达式的值。
• 样例输入
• 1-2+3*((4-5)*1)
• 样例输出
• -4
• 数据规模和约定
• 表达式长度不超过100，表达式运算合法且运算过程都在int内进行。
  */

/**

• 设计思想：

• 1、设置两个栈，一个数字栈，一个符号栈

• 2、进行优先级的判断，如果当前符号的优先级高于符号栈栈顶符号，就直接入栈；如果优先级低于栈顶符号，取出栈顶元素进行运算，将新的数值结果加入到数字栈，当前符号加入到符号栈

• 3、当符号栈为空，数字栈就剩一个元素时，该元素就是结果，输出
  /
  public class Forum {
  public static void main(String[] args) {
  Stack od=new Stack();//数字栈
  Stack op=new Stack();//符号栈
  int result=0;
  Scanner scanner=new Scanner(System.in);
  String text=scanner.nextLine();
  int index=0;
  int length=text.length();
  while(index<length){
  char c=text.charAt(index);//取出这一步符号
  if(c==’(’){
  op.push©;//将左括号入栈
  }
  else if(c==’+’ || c==’-’ || c==’’ || c==’/’){
  int currlevel=judge©; //当前符号优先级
  while(true){
  int stacklevel=0;
  if(op.isEmpty()==false){
  Object obj=op.peek();//获取栈顶元素，但是不删除栈顶元素
  stacklevel=judge((char)obj);
  }
  if(currlevel>stacklevel){
  //直接入栈
  op.push©;
  break;
  }
  else{//需要先计算再入栈
  try{
  char optemp=‘0’;
  int odnum1=0;
  int odnum2=0;
  if(op.isEmpty()==false){
  optemp=(char)op.pop(); //取运算符号
  }
  if(od.isEmpty()==false){
  odnum1= (int) od.pop(); //取操作数
  odnum2= (int) od.pop();
  }
  od.push(getResult(odnum2,odnum1,optemp)); //新计算的值入栈
  }catch (Exception e){
  e.printStackTrace();
  }

               }
           }
       }
       else if(c==')'){
           while(true){
              char theop= (char) op.pop();
              if(theop=='('){
                  break;
              }
              else {
                  try{
                      int odnum1= (int) od.pop();
                      int odnum2= (int) od.pop();
                      od.push(getResult(odnum2,odnum1,theop));
  
                  }catch (Exception e){
                      e.printStackTrace();
                  }
              }
           }
       }else if(c>='0' && c<='9'){ //输入的是数字
          int tempindex=index+1;
          while(tempindex<length){
              char tempc=text.charAt(tempindex);
              if(tempc>='0' && tempc<='9'){
                  tempindex++;
              }else {
                  break;//数取完了
              }
          }
          String odstr=text.substring(index,tempindex);
          try{
                 //将数字转化成整数
              int odnum=Integer.parseInt(odstr);
              od.push(odnum);
              index=tempindex-1;
          }catch (Exception e){
              e.printStackTrace();
          }
       }
       index++;
   }
   while(true){
       Object obj=null;
       if(op.isEmpty()==false){
           obj=op.pop();
       }
       if(obj==null){
           break;
       }
       else {
           char optemp=(char)obj;
           int odnum1=(int)od.pop();
           int odnum2=(int)od.pop();
           //  System.out.println(cacuResult(optemp,odnum2,odnum1)+"-------进栈");
           od.push(getResult(odnum2,odnum1,optemp));
  
       }
   }
   try{
       result=(int)od.pop();
   }catch(Exception e)
   {
       //System.out.println("多项式不正确4"+str);
       e.printStackTrace();
   }
   System.out.println(result);
  

  }

// //判断优先级
public static int judge(char ch){
switch(ch){
case ‘(’:return 0;
case ‘+’:
case ‘-’:return 1;
case ‘*’:
case ‘/’:return 2;
default:return 0;
}
}

//计算结果
public static int getResult(int  ch1,int  ch2,char deal){
    int sum=0;
    if(deal=='+'){
        sum=ch1+ch2;
    }
    else if(deal=='-'){
        sum=ch1-ch2;
    }
    else if(deal=='*'){
        sum=ch1*ch2;
    }
    else if(deal=='/'){
        sum=ch1/ch2;
    }
    return sum;
}

}