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

题目相关

       首先复习一下逆波兰表达式的相关知识：

      逆波兰表达式的解释器一般是基于堆栈的。解释过程一般是：操作数入栈；遇到操作符时，操作数出栈，求值，将结果入栈；当一遍后，栈顶就是表达式的值。因此逆波兰表达式的求值使用堆栈结构很容易实现，并且能很快求值。

       下面以(a+b)*c为例子进行说明： 
(a+b)*c的逆波兰式为ab+c*，假设计算机把ab+c*按从左到右的顺序压入栈中，并且按照遇到运算符就把栈顶两个元素出栈，执行运算，得到的结果再入栈的原则来进行处理，那么ab+c*的执行结果如下： 

      a入栈（0位置）；
      b入栈（1位置）；
      遇到运算符“+”，将a和b出栈，执行a+b的操作，得到结果d=a+b，再将d入栈（0位置）；
      c入栈（1位置）；
      遇到运算符“*”，将d和c出栈，执行d*c的操作，得到结果e，再将e入栈（0位置）。
      经过以上运算，计算机就可以得到(a+b)*c的运算结果e了。

     逆波兰式计算等式的实现非常容易，使用堆栈即可完成。在程序中，需要实现整数与字符串之间的相互转换。
 

示例代码

C++：

class Solution {
public:
    int evalRPN(vector<string> &tokens) {
        if (tokens.size() == 0)
            return 0;
        stack<int> stack_num;
        for(int i = 0; i < tokens.size(); i++)
        {
            string s = tokens[i];
            if(s == "+" || s == "-" || s == "*" || s == "/")
               {
                   if(stack_num.size() < 2)
                       return 0;
                   int secondNum = stack_num.top();
                   stack_num.pop();
                   int firstNum = stack_num.top();
                   stack_num.pop();
                   int result = getResult(firstNum, secondNum, s);
                   stack_num.push(result);
               }
              else
               {
                   stack_num.push(atoi(s.c_str()));
               }
    }
               return stack_num.top();
    }
    int getResult(int firstNum, int secondNum, string s)
    {
       if(s == "+")
           return firstNum + second  Num;
        else if(s == "-")
            return firstNum - secondNum;
        else if(s == "*")
            return firstNum*secondNum;
        else if(s == "/")
            return firstNum/secondNum;
        return 0;
    }
};

Java：

import java.util.Stack;
public class Solution {
    public int evalRPN(String[] tokens) {
        if(tokens.length == 0)
            return 0;
        int right = 0;
        int left = 0;
        int result = 0;
        Stack<Integer>  stack = new Stack<Integer>();
        for (int i = 0; i < tokens.length; i++)
        {
            if(tokens[i].equals("+"))
            {
                right = stack.pop();
                left = stack.pop();
                result = right + left;
                stack.push(result);
            }else if(tokens[i].equals("-"))
            {
                right = stack.pop();
                left = stack.pop();
                result = left - right;
                stack.push(result);
            } else if(tokens[i].equals("*"))
            {
                right = stack.pop();
                left = stack.pop();
                result = left*right;
                stack.push(result);
            } else if(tokens[i].equals("/"))
            {
                right = stack.pop();
                left = stack.pop();
                result = left/right;
                stack.push(result);
            }
            else
                stack.push(Integer.parseInt(tokens[i]));
        }
        return stack.pop();
    }
}