catalogue

Inverse Polish expression evaluation

Method 2: array simulation stack

# Inverse Polish expression evaluation

## describe

Find the value of the expression according to the inverse Polish representation.

Valid operators include +,-,*,/ . Each operand can be an integer or another inverse expression.

## explain

Integer division preserves only the integer part.

The given inverse Polish expression is always valid. In other words, an expression always yields a valid value and there is no case where the divisor is 0.

## Example one

Input: tokens = ["2","1","+","3","*"] Output: 9 Explanation: this expression is transformed into a common infix arithmetic expression:((2 + 1) * 3) = 9

## Example two

Input: tokens = ["4","13","5","/","+"] Output: 6 Explanation: this expression is transformed into a common infix arithmetic expression:(4 + (13 / 5)) = 6

## Example three

Input: tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"] Output: 22 Explanation: This expression is transformed into a common infix arithmetic expression as follows: ((10 * (6 / ((9 + 3) * -11))) + 17) + 5 = ((10 * (6 / (12 * -11))) + 17) + 5 = ((10 * (6 / -132)) + 17) + 5 = ((10 * 0) + 17) + 5 = (0 + 17) + 5 = 17 + 5 = 22

## Tips

- tokens[i] is either an operator ("+", "-", "*" or "/") or an integer in the range [- 200, 200]

## Reverse Polish notation

Inverse Polish expression is a suffix expression. The so-called suffix means that the operator is written after it.

The commonly used formula is an infix expression, such as (1 + 2) * (3 + 4).

The inverse Polish expression of the formula is written as ((1,2 +) (3,4 +) *).

The inverse Polish expression has the following two advantages:

After removing the brackets, the expression is unambiguous. Even if the above formula is written as 1 2 + 3 4 + *, the correct result can be calculated according to the order.

Suitable for stack operation: enter the stack when encountering numbers; In case of an operator, take out the two numbers at the top of the stack for calculation, and press the result into the stack.

## Method: stack

In fact, the topic has already said the idea of solving the problem. This topic is suitable for stack operation.

If a number is encountered, it will be put on the stack; In case of an operator, take out the two numbers at the top of the stack for calculation, and press the result into the stack.

We use regular expressions to determine whether the current character is a number.

import java.util.regex.Pattern; class Solution { public int evalRPN(String[] tokens) { Stack<String> stack=new Stack<>(); int n1,n2; for (int i = 0; i < tokens.length; i++) { if (isNumber(tokens[i])){//If number stack.push(tokens[i]);//Push }else{//If it is an operation symbol n2=Integer.parseInt(stack.pop());//Operand 2 n1=Integer.parseInt(stack.pop());//Operand 1 if ("+".equals(tokens[i])) stack.push(n1+n2+"");//Writes the result back to the stack else if ("-".equals(tokens[i])) stack.push(n1-n2+"");//Writes the result back to the stack else if ("*".equals(tokens[i])) stack.push(n1*n2+"");//Writes the result back to the stack else if ("/".equals(tokens[i])) stack.push(n1/n2+"");//Writes the result back to the stack } } return Integer.parseInt(stack.pop());//Return final result } public boolean isNumber(String string) {//Regular expression determines whether it is a number if (string == null) return false; Pattern isNumber = Pattern.compile("^-?\\d+(\\.\\d+)?$"); return isNumber.matcher(string).matches(); } }

## Method 2: array simulation stack

For a valid inverse Polish expression, its length n must be odd, and there must be one more operand than the operator (that is, the number of operands is (n+1)/2, and the operator is (n-1)/2)

We define an array stack with a length of (n+1)/2 to simulate the stack, and define an index variable to indicate the position of the top element of the stack (initialized to - 1). When operands and operators are encountered:

- Operand: move index to the right, and assign the operand to stack[index], that is, stack[++index]=tokens[i]
- Operator: shift index to the left, operate the left operand stack[index] and the right operand stack[index+1], and assign the result to stack[index] (for example, stack[--index]=stack[index]+stack[index+1])

class Solution { public int evalRPN(String[] tokens) { int[] stack=new int[(tokens.length+1)/2]; int index=-1;//Point to stack top element for (int i = 0; i < tokens.length; i++) { String token=tokens[i]; switch (token){ case "+"://If it is an operator, the calculation results coexist back to the array stack[--index]=stack[index]+stack[index+1]; break; case "-": stack[--index]=stack[index]-stack[index+1]; break; case "*": stack[--index]=stack[index]*stack[index+1]; break; case "/": stack[--index]=stack[index]/stack[index+1]; break; default://If it is a number, it is stacked stack[++index]=Integer.parseInt(token); } } return stack[index]; } }