leetcode--Evaluate Reverse Polish Notation

傷城~ 2021-10-24 03:44 164阅读 0赞

Evaluate the value of an arithmetic expression in [Reverse Polish Notation][].

Valid operators are `+`, `-`, `*`, `/`. Each operand may be an integer or another expression.

Some examples:

["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
      ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

1 public class Solution{
     2     public int evalRPN(String[] tokens) {
     3         Stack<Integer> nums = new Stack<Integer>();
     4         HashSet<String> opers = new HashSet<String>();
     5         opers.add("+");
     6         opers.add("-");
     7         opers.add("/");
     8         opers.add("*");
     9         int length = tokens.length;
    10         for(int i = 0; i < length; ++i){
    11             if(opers.contains(tokens[i])){
    12                 int b = nums.pop();
    13                 int a = nums.pop();
    14                 nums.push(doOpers(a, b, tokens[i]));
    15             }
    16             else
    17                 nums.push(Integer.parseInt(tokens[i]));
    18         }
    19         return nums.pop();
    20     }
    21 
    22     //I used java 7.
    23     public int doOpers(int a , int b, String opers){
    24         int result = 0;
    25         switch(opers){
    26             case "+": result = a + b;
    27                          break;
    28             case "-": result = a - b;
    29                          break;
    30             case "*": result = a * b;
    31                          break;
    32             case "/": result = a / b;
    33                          break;
    34         }
    35         return result;
    36     }    
    37 }

Notice, we need to add the **zero divisor Exception.**

The following code takes the exception into account.

public class Solution {
        public int evalRPN(String[] tokens) {
            int result = 0;
            Stack<Integer> st = new Stack<Integer>();
            int len = tokens.length;
            for(int i = 0; i < len; ++i){
                if(!isOperator(tokens[i]))
                    st.push(Integer.parseInt(tokens[i]));
                else{
                    int b = st.pop();
                    int a = st.pop();
                    try{
                        st.push(doCalculations(a, b, tokens[i]));
                    }
                    catch (ArithmeticException e){
                        e.printStackTrace();
                    }
                }
            }
            result = st.pop();
            return result;
        }
    
        public boolean isOperator(String s){
            return s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/");
        }
    
        public int doCalculations (int inta, int intb, String c){
            int result = 0;
            switch(c){
                case "+": result = inta + intb;
                          break;
                case "-": result = inta - intb;
                          break;
                case "*": result = inta * intb;
                          break;
                default:
                          break;                    
            }
    
            if(c.equals("/")){
                if(intb != 0)
                    result = inta / intb;
                else
                    throw new ArithmeticException("zero divisor!");
             }
            return result;
        }
    }

转载于:https://www.cnblogs.com/averillzheng/p/3536448.html

[Reverse Polish Notation]: http://en.wikipedia.org/wiki/Reverse_Polish_notation