【编程题】简单的四则运算

问题描述： 输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注： 1、表达式只含 +, -, *, /, (, ), 四则运算符
2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况
3、要考虑加减乘除按通常四则运算规定的计算优先级
4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生
5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况
• 要求实现函数： 
int calculate(int len,char *expStr)
【输入】 int len: 字符串长度；
char *expStr: 表达式字符串；
【输出】 无
【返回】 计算结果

• 示例 
1） 输入：char *expStr = “1+4*5-8/3”
函数返回：19
2） 输入：char *expStr = “8/3*3”
函数返回：6 

package MyTest;

/**
 * 简单的四则运算，每个参与运算的数字都在0-9之间。
 */

import java.util.*;

public class FourOps {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            String expretion = in.next();
            int length = expretion.length();
            int result = compute(length, expretion);
            System.out.println(result);
        }

    }
    
    /**
     * 该函数有两个功能
     * 1. 首先把一个正常的中缀表达式，转化为一个后缀表达式
     * 2. 通过后缀表达式计算表达式的值
     * @param length
     * @param expretion
     * @return
     */
    private static int compute(int length, String expretion) {
        int result = 0;
        List<Character> oneOps = new LinkedList<>();
        oneOps.add('+');
        oneOps.add('-');
        List<Character> twoOps = new LinkedList<>();
        twoOps.add('*');
        twoOps.add('/');
        LinkedList<Character> ops = new LinkedList<>(); //用作栈，前面一定也要是LinkedList
        StringBuffer changedExp = new StringBuffer();
        for(int i = 0; i < length; i++){
            Character temp = expretion.charAt(i);
            if(temp >= '0' && temp <= '9')
                changedExp.append(temp);
            else{
                if(ops.isEmpty())
                    ops.push(temp);
                else{
                    if(temp == '(')
                        ops.push(temp);
                    else{
                        if(oneOps.contains(temp)){
//                            if(ops.peek() != '(')
                            //原来用的if，考虑在遇到+-的时候应该把栈里的运算符都pop出来，现在改用while
                            while(!ops.isEmpty()){
                                if(ops.peek() == '(')
                                    break;
                                changedExp.append(ops.pop());
                            }                                    
                            ops.push(temp);
                        }
                        else if(twoOps.contains(temp) && twoOps.contains(ops.peek())){    //为了连续的/法
                            changedExp.append(ops.pop());
                            ops.push(temp);
                        }
                        else if(temp != ')'){
                            ops.push(temp);
                        }
                        else{    //')'的情况
                            while(ops.peek() != '('){
                                changedExp.append(ops.pop());
                            }
                            ops.pop();
                        }
                    }
                }
            }
        }
        while(!ops.isEmpty()){
            changedExp.append(ops.pop());
        }
        String changedExpStr = changedExp.toString();
        System.out.println(changedExpStr);    //输出转化后的后缀表达式
        
        //用后缀表达式计算
        LinkedList<Integer> nums = new LinkedList<>();
        for(int i = 0; i < changedExpStr.length(); i++){
            Character temp = changedExpStr.charAt(i);
            if(temp >= '0' && temp <= '9'){
                nums.push(temp-'0');
            }
            else{
                int a = nums.pop();
                int b = nums.pop();
                switch(temp){
                case '+': nums.push(a+b); break;
                case '-': nums.push(b-a); break;
                case '*': nums.push(a*b); break;
                case '/': nums.push(b/a); break;
                }
            }
        }
        result = nums.pop();
        return result;
    }

}