 Open in App
Not now

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

• Difficulty Level : Easy
• Last Updated : 23 Dec, 2022

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:

## C++

 `#include ``using` `namespace` `std;``int` `eval(vector& A)``{``    ``stack<``int``> st;``    ``for` `(``int` `i = 0; i < A.size(); i++) {``        ``if` `(A[i] != ``"+"` `&& A[i] != ``"-"` `&& A[i] != ``"/"``            ``&& A[i] != ``"*"``) {``            ``st.push(stoi(A[i]));``            ``continue``;``        ``}``        ``else` `{``            ``int` `b = st.top();``            ``st.pop();``            ``int` `a = st.top();``            ``st.pop();``            ``if` `(A[i] == ``"+"``)``                ``st.push(a + b);``            ``else` `if` `(A[i] == ``"-"``)``                ``st.push(a - b);``            ``else` `if` `(A[i] == ``"*"``)``                ``st.push(a * b);``            ``else``                ``st.push(a / b);``        ``}``    ``}``    ``return` `st.top();``}` `int` `main()``{``    ``vector A``        ``= { ``"10"``, ``"6"``, ``"9"``,  ``"3"``, ``"+"``, ``"-11"``, ``"*"``,``            ``"/"``,  ``"*"``, ``"17"``, ``"+"``, ``"5"``, ``"+"` `};` `    ``int` `res = eval(A);``    ``cout << res << endl;``}`

## 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 popping``                ``// 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 popping``                ``// 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``;` `            ``case` `"*"``:` `                ``// Performing the "*" operation``                ``// by popping 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 popping``                ``// 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);``    ``}``}`

## Python3

 `# Python 3 code to evaluate reverse polish notation` `"""``This code is contributed by Harshal Gupta``"""` `# function to evaluate reverse polish notation``def` `evaluate(expression):``  ``# splitting expression at whitespaces``  ``expression ``=` `expression.split()``  ` `  ``# stack``  ``stack ``=` `[]``  ` `  ``# iterating expression``  ``for` `ele ``in` `expression:``    ` `    ``# ele is a number``    ``if` `ele ``not` `in` `'/*+-'``:``      ``stack.append(``int``(ele))``    ` `    ``# ele is an operator``    ``else``:``      ``# getting operands``      ``right ``=` `stack.pop()``      ``left ``=` `stack.pop()``      ` `      ``# performing operation according to operator``      ``if` `ele ``=``=` `'+'``:``        ``stack.append(left ``+` `right)``        ` `      ``elif` `ele ``=``=` `'-'``:``        ``stack.append(left ``-` `right)``        ` `      ``elif` `ele ``=``=` `'*'``:``        ``stack.append(left ``*` `right)``        ` `      ``elif` `ele ``=``=` `'/'``:``        ``stack.append(``int``(left ``/` `right))``  ` `  ``# return final answer.``  ``return` `stack.pop()` `# input expression``arr ``=` `"10 6 9 3 + -11 * / * 17 + 5 +"` `# calling evaluate()``answer ``=` `evaluate(arr)``# printing final value of the expression``print``(f``"Value of given expression'{arr}' = {answer}"``)``        ` `        ` `        ` `        ` `        ` `       `

## C#

 `// C# Program to find the``// solution of the arithmetic``// using the stack` `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `  ``public` `class` `Solution {``    ``public` `int` `stacky(``string``[] tokens)``    ``{``      ``// Initialize the stack and the variable``      ``Stack<``string``> stack = ``new` `Stack<``string``>();``      ``int` `x, y;``      ``string` `result = ``""``;``      ``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``            ``// popping put the first two character``            ``// and then again store back to the``            ``// stack` `            ``x = ``int``.Parse(stack.Pop());``            ``y = ``int``.Parse(stack.Pop());``            ``value = x + y;``            ``result = p + value;``            ``stack.Push(result);``            ``break``;` `          ``case` `"-"``:``            ``// Performing the "-" operation by``            ``// popping put the first two character``            ``// and then again store back to the``            ``// stack``            ``x = ``int``.Parse(stack.Pop());``            ``y = ``int``.Parse(stack.Pop());``            ``value = y - x;``            ``result = p + value;``            ``stack.Push(result);``            ``break``;` `          ``case` `"*"``:``            ``// Performing the "*" operation``            ``// by popping put the first two``            ``// character and then again store back``            ``// to the stack` `            ``x = ``int``.Parse(stack.Pop());``            ``y = ``int``.Parse(stack.Pop());``            ``value = x * y;``            ``result = p + value;``            ``stack.Push(result);``            ``break``;` `          ``case` `"/"``:``            ``// Performing the "/" operation by``            ``// popping put the first two character``            ``// and then again store back to the``            ``// stack` `            ``x = ``int``.Parse(stack.Pop());``            ``y = ``int``.Parse(stack.Pop());``            ``value = y / x;``            ``result = p + value;``            ``stack.Push(result);``            ``break``;` `          ``default``:``            ``continue``;``        ``}``      ``}` `      ``// Method to convert the String to integer``      ``return` `int``.Parse(stack.Pop());``    ``}``  ``}` `  ``static` `public` `void` `Main()``  ``{` `    ``// String Input``    ``string``[] s``      ``= { ``"10"``, ``"6"``, ``"9"``,  ``"3"``, ``"+"``, ``"-11"``, ``"*"``,``         ``"/"``,  ``"*"``, ``"17"``, ``"+"``, ``"5"``, ``"+"` `};` `    ``Solution str = ``new` `Solution();``    ``int` `result = str.stacky(s);``    ``Console.WriteLine(``      ``"Value of given expression'10 6 9 3 + -11 * / * 17 + 5 +' = "``      ``+ result);``  ``}``}` `// This code is contributed by lokesh`

## Javascript

 `// Javascript code to evaluate reverse polish notation   ``function` `eval(A)``{` `    ``// Initialize the stack``    ``let st = [];``    ` `    ``// Iterating to the each character``    ``// in the array of the string``    ``for` `(let i = 0; i < A.length; i++)``    ``{``    ` `        ``// If the character is not the special character``        ``// ('+', '-' ,'*' , '/')``        ``// then push the character to the stack``        ``if` `(A[i] != ``"+"` `&& A[i] != ``"-"` `&& A[i] != ``"/"``            ``&& A[i] != ``"*"``) {``            ``st.push(parseInt(A[i]));``            ``continue``;``        ``}``        ` `         ``// else if the character is the special``         ``// character then use them to``         ``// perform the action``        ``else` `{``            ``let b = parseInt(st.pop());``            ``let a = parseInt(st.pop());``            ``if` `(A[i] == ``"+"``)``                ``st.push(a + b);``            ``else` `if` `(A[i] == ``"-"``)``                ``st.push(a - b);``            ``else` `if` `(A[i] == ``"*"``)``                ``st.push(a * b);``            ``else``                ``st.push(parseInt(a / b));``        ``}``    ``}``    ``return` `parseInt(st[st.length-1]);``}` `    ``let A = [ ``"10"``, ``"6"``, ``"9"``, ``"3"``, ``"+"``, ``"-11"``, ``"*"``,``            ``"/"``, ``"*"``, ``"17"``, ``"+"``, ``"5"``, ``"+"` `];` `    ``let res = eval(A);``    ``console.log(res);``    ` `    ``// This code is contributed by Pushpesh Raj.`

Output

`Value of given expression'10 6 9 3 + -11 * / * 17 + 5 +' = 22`

Time complexity: O(n)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up