leetcode--Evaluate Reverse Polish Notation

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