Skip to content
Related Articles

Related Articles

Improve Article

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<String> stack = new Stack<String>();
        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
Recommended Articles
Page :