Related Articles

# Evaluate the Value of an Arithmetic Expression in Reverse Polish Notation in Java

• Difficulty Level : Easy
• Last Updated : 12 Jul, 2021

Reverse Polish ‘Notation is postfix notation which in terms of mathematical notion signifies operators following operands. Let’s take a problem statement to implement RPN

Problem Statement: The task is to find the value of the arithmetic expression present in the array using valid operators like +, -, *, /. Each operand may be an integer or another expression.

Note:

1. The division between two integers should truncate toward zero.
2. The given RPN expression is always valid. That means the expression would always evaluate to a result and there won’t be any divide by zero operation.

Layman Working of RPN as shown

```Input: ["2", "1", "+", "3", "*"]
Output: 9
Explanation: ((2 + 1) * 3) = 9

Input: ["4", "13", "5", "/", "+"]
Output: 6
Explanation: (4 + (13 / 5)) = 6

Input: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
Output: 22
Explanation:
((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```

Approach:

The basic approach for the problem is using the stack.

• Accessing all elements in the array, if the element is not matching with the special character (‘+’, ‘-‘,’*’, ‘/’) then push the element to the stack.
• Then whenever the special character is found then pop the first two-element from the stack and perform the action and then push the element to stack again.
• Repeat the above two process to all elements in the array
• At last pop the element from the stack and print the Result

Implementation:

## Java

 `// Java Program to find the``// solution of the arithmetic``// using the stack``import` `java.io.*;``import` `java.util.*;` `class` `solution {``    ``public` `int` `stacky(String[] tokens)``    ``{` `        ``// Initialize the stack and the variable``        ``Stack stack = ``new` `Stack();``        ``int` `x, y;``        ``String result = ``""``;``        ``int` `get = ``0``;``        ``String choice;``        ``int` `value = ``0``;``        ``String p = ``""``;` `        ``// Iterating to the each character``        ``// in the array of the string``        ``for` `(``int` `i = ``0``; i < tokens.length; i++) {` `            ``// If the character is not the special character``            ``// ('+', '-' ,'*' , '/')``            ``// then push the character to the stack``            ``if` `(tokens[i] != ``"+"` `&& tokens[i] != ``"-"``                ``&& tokens[i] != ``"*"` `&& tokens[i] != ``"/"``) {``                ``stack.push(tokens[i]);``                ``continue``;``            ``}``            ``else` `{``                ``// else if the character is the special``                ``// character then use the switch method to``                ``// perform the action``                ``choice = tokens[i];``            ``}` `            ``// Switch-Case``            ``switch` `(choice) {``            ``case` `"+"``:` `                ``// Performing the "+" operation by poping``                ``// put the first two character``                ``// and then again store back to the stack` `                ``x = Integer.parseInt(stack.pop());``                ``y = Integer.parseInt(stack.pop());``                ``value = x + y;``                ``result = p + value;``                ``stack.push(result);``                ``break``;` `            ``case` `"-"``:` `                ``// Performing the "-" operation by poping``                ``// put the first two character``                ``// and then again store back to the stack``                ``x = Integer.parseInt(stack.pop());``                ``y = Integer.parseInt(stack.pop());``                ``value = x - y;``                ``result = p + value;``                ``stack.push(result);``                ``break``;` `            ``case` `"*"``:` `                ``// Performing the "*" operation``                ``// by poping put the first two character``                ``// and then again store back to the stack` `                ``x = Integer.parseInt(stack.pop());``                ``y = Integer.parseInt(stack.pop());``                ``value = x * y;``                ``result = p + value;``                ``stack.push(result);``                ``break``;` `            ``case` `"/"``:` `                ``// Performing the "/" operation by poping``                ``// put the first two character``                ``// and then again store back to the stack` `                ``x = Integer.parseInt(stack.pop());``                ``y = Integer.parseInt(stack.pop());``                ``value = y / x;``                ``result = p + value;``                ``stack.push(result);``                ``break``;` `            ``default``:``                ``continue``;``            ``}``        ``}` `        ``// Method to convert the String to integer``        ``return` `Integer.parseInt(stack.pop());``    ``}``}` `class` `GFG {``  ` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``// String Input``        ``String[] s``            ``= { ``"10"``, ``"6"``, ``"9"``,  ``"3"``, ``"+"``, ``"-11"``, ``"*"``,``                ``"/"``,  ``"*"``, ``"17"``, ``"+"``, ``"5"``, ``"+"` `};``      ` `        ``solution str = ``new` `solution();``        ``int` `result = str.stacky(s);``        ``System.out.println(result);``    ``}``}`

Output :

`22`

Time complexity: O(n)

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up