算法 计算四则运算字符串结果

Posted 2022-04-03 lvjianwei

RingBuffer面试后面一场，输入一个字符串，计算结果

字符串内容限制为“ 0-9，+，-，*，/”这些符号

例如输入"1+2*3/4-5"，返回-2.5。

 

开始到时候直接想到了可以用树来维护计算关系，后来被问可以用其他数据结构么，然后想到应该用栈来实现，写的时候用了一个，写到后面突然意识到应该用两个栈，一个存数据，一个存操作符。

在家里写了完成大概写了一个小时不到，当时是没写完，后来口述了一下逻辑。

重点在于：

1.第一个符号到判断，可能第一个字符是“+”或者“-”。

2.末尾非法符号判断。

3.中间连续连个操作符的判断。

具体是几行粗体代码

 

package com.ljw.javatest;

import java.util.LinkedList;
import java.util.Stack;

public class Calculate 

    public static void print(Object value) 
        System.out.println(value);
    

    public static void main(String[] args) throws Exception 
        String input = null;

        input = "1+2*3/4-5";
        print(calculate(input) == -2.5);

        input = "-1+2*3/4-5";
        print(calculate(input) == -4.5);

        try 
            input = "";
            calculate(input);
         catch (Exception ex) 
            print(ex.getMessage().equals(exMsg));
        

        try 
            input = null;
            calculate(input);
         catch (Exception ex) 
            print(ex.getMessage().equals(exMsg));
        

        try 
            input = "1+2*3/4-a5";
            calculate(input);
         catch (Exception ex) 
            print(ex.getMessage().equals(exMsg));
        

        try 
            input = "1+2*a3/4-5";
            calculate(input);
         catch (Exception ex) 
            print(ex.getMessage().equals(exMsg));
        

        try 
            input = "1+2**3/4-5";
            calculate(input);
         catch (Exception ex) 
            print(ex.getMessage().equals(exMsg));
        

        try 
            input = "1+2*3/4+-5";
            calculate(input);
         catch (Exception ex) 
            print(ex.getMessage().equals(exMsg));
        

        try 
            input = "1+-2*3/4-5";
            calculate(input);
         catch (Exception ex) 
            print(ex.getMessage().equals(exMsg));
        

        
        try 
            input = "1-2*3/4-5-";
            calculate(input);
         catch (Exception ex) 
            print(ex.getMessage().equals(exMsg));
        

    

    static String exMsg = "invalid input";

    public static double calculate(String input) throws Exception 
        if (input == null || input.length() == 0) 
            throw new Exception(exMsg);
        

        char[] arr = input.toCharArray();
        Stack<Double> valueStack = new Stack();
        Stack<String> opStack = new Stack();

        StringBuilder sb = new StringBuilder();
        boolean flag = false;
        for (int i = 0; i < arr.length; i++) 
            char temp = arr[i];
            if (temp != ‘+‘ && temp != ‘-‘ && temp != ‘*‘ && temp != ‘/‘) 
                if (temp < ‘0‘ || temp > ‘9‘) 
                    throw new Exception(exMsg);
                
                sb.append(temp);

                continue;
            
            Double value = null;
            if (sb.length() != 0) 
                value = Double.parseDouble(sb.toString());
                sb.setLength(0);
            

            if(i<arr.length-1
                &&!(arr[i+1] != ‘+‘ && arr[i+1] != ‘-‘ && arr[i+1] != ‘*‘ && arr[i+1] != ‘/‘))
                throw new Exception(exMsg);
            
            if(i==arr.length-1)
                throw new Exception(exMsg);
            

            if (flag) 
                if (value == null) 
                    throw new Exception(exMsg);
                
                Double a = valueStack.pop();
                String op = opStack.pop();
                switch (op) 
                case "*":
                    value = a * value;
                    break;
                case "/":
                    value = a / value;
                    break;
                // default:
                //     throw new Exception(exMsg);
                
                valueStack.push(value);
             else 
                if (value != null) 
                    valueStack.push(value);
                
            

            opStack.push(String.valueOf(temp));
            if (temp == ‘+‘ || temp == ‘-‘) 
                flag = false;
             else 
                flag = true;
            
        
        // if (sb.length() == 0) 
        //     throw new Exception(exMsg);
        // 
        valueStack.push(Double.parseDouble(sb.toString()));

        double result = valueStack.pop();

        while (!valueStack.isEmpty() && !opStack.isEmpty()) 
            double value = valueStack.pop();
            String op = opStack.pop();
            // 第一个输入可能是带符号
            if (valueStack.isEmpty() && opStack.size() == 1) 
                String extra = opStack.pop();
                if (extra.equals("-")) 
                    value = 0 - value;
                
            
            switch (op) 
            case "-":
                result = value - result;
                break;
            case "+":
                result = value + result;
                break;
            // default:
            //     throw new Exception(exMsg);
            

        

        // if (!valueStack.isEmpty() || !opStack.isEmpty()) 
        //     throw new Exception(exMsg);
        // 

        return result;