Related Articles

# Java Program to Implement Shunting Yard Algorithm

• Difficulty Level : Easy
• Last Updated : 16 Aug, 2021

The shunting yard algorithm is used to convert the infix notation to reverse polish notation. The postfix notation is also known as the reverse polish notation (RPN). The algorithm was named a “Shunting yard” because its activity is similar to a railroad shunting yard. It is a method for representing expressions in which the operator symbol is placed after the arguments being operated on. Polish notation, in which the operator comes before the operands. Australian philosopher and computer scientist suggested placing the operator after the operands and hence created reverse polish notation.  Dijkstra developed this algorithm

Representation and Interpretation:

Brackets are not required to represent the order of evaluation or grouping of the terms. RPN expressions are simply evaluated from left to right and this greatly simplifies the computation of the expression within computer programs. As an example, the arithmetic expression.

Interpreting from left to right the following two executions can be performed

1. If the value appears next in the expression push the current value in the stack.
2. Now, if the operator appears next, pop the topmost two elements from the stack, execute the operation and push back the result into the stack.

The order of precedence of operators is:

Illustration: RPN expression will produce the sum of 2 and 3, namely 5: 2 3 +

Input: (3+4)*5

Output: 3×4+5*

This is the postfix notation of the above infix notation

Concepts Involved:

Examples:

Infix Notation:   a+b*(c^d-e)^(f+g*h)-i

Postfix Notation: abcd^e-fgh*+^*+i-

Algorithm: AE is the arithmetic expression written in infix notation PE will be the postfix expression of AE

1. Push “(“ onto Stack, and add “)” to the end of AE.
2. Scan AE from left to right and repeat Step 3 to 6 for each element of AE until the Stack is empty.
3. If an operand is encountered, append it to PE.
4. If a left parenthesis is encountered, push it onto Stack.
5. If an operator is encountered, then: Repeatedly pop from Stack and append to PE each operator which has the same precedence as or higher precedence than the operator. Add an operator to Stack. [End of if]
6. If a right parenthesis is encountered, then: Repeatedly pop from Stack and append to PE each operator until a left parenthesis is encountered.     Remove the left Parenthesis.  [End of If] [End of If]
7. g×h

Applying the same above algorithms for two examples given below:

Example 1 : Applying Shunting yard algorithm on the expression “1 + 2”

Step 1: Input “1 + 2”

Step 2: Push 1 to the output queue

Step 3: Push + to the operator stack, because + is an operator.

Step 4: Push 2 to the output queue

Step 5: After reading the input expression, the output queue and operator stack pop the expression and then add them to the output.

Step 6: Output “1 2 +”

Example 2: Applying the Shunting yard algorithm on the expression 5 + 2 / (3- 8) ^ 5 ^ 2

Implementing: Shunting Yard Algorithm

## Java

 `// Java Implemention of Shunting Yard Algorithm` `// Importing stack class for stacks DS``import` `java.util.Stack;``// Importing specific character class as``// dealing with only operators and operands``import` `java.lang.Character;` `class` `GFG {` `    ``// Method is used to get the precedence of operators``    ``private` `static` `boolean` `letterOrDigit(``char` `c)``    ``{``        ``// boolean check``        ``if` `(Character.isLetterOrDigit(c))``            ``return` `true``;``        ``else``            ``return` `false``;``    ``}` `    ``// Operator having higher precedence``    ``// value will be returned``    ``static` `int` `getPrecedence(``char` `ch)``    ``{` `        ``if` `(ch == ``'+'` `|| ch == ``'-'``)``            ``return` `1``;``        ``else` `if` `(ch == ``'*'` `|| ch == ``'/'``)``            ``return` `2``;``        ``else` `if` `(ch == ``'^'``)``            ``return` `3``;``        ``else``            ``return` `-``1``;``    ``}` `    ``// Method converts  given infixto postfix expression``    ``// to illustrate shunting yard algorithm``    ``static` `String infixToRpn(String expression)``    ``{``        ``// Initialising an empty String``        ``// (for output) and an empty stack``        ``Stack stack = ``new` `Stack<>();` `        ``// Initially empty string taken``        ``String output = ``new` `String(``""``);` `        ``// Iterating ovet tokens using inbuilt``        ``// .length() function``        ``for` `(``int` `i = ``0``; i < expression.length(); ++i) {``            ``// Finding character at 'i'th index``            ``char` `c = expression.charAt(i);` `            ``// If the scanned Token is an``            ``// operand, add it to output``            ``if` `(letterOrDigit(c))``                ``output += c;` `            ``// If the scanned Token is an '('``            ``// push it to the stack``            ``else` `if` `(c == ``'('``)``                ``stack.push(c);` `            ``// If the scanned Token is an ')' pop and append``            ``// it to output from the stack until an '(' is``            ``// encountered``            ``else` `if` `(c == ``')'``) {``                ``while` `(!stack.isEmpty()``                       ``&& stack.peek() != ``'('``)``                    ``output += stack.pop();` `                ``stack.pop();``            ``}` `            ``// If an operator is encountered then taken the``            ``// further action based on the precedence of the``            ``// operator` `            ``else` `{``                ``while` `(``                    ``!stack.isEmpty()``                    ``&& getPrecedence(c)``                           ``<= getPrecedence(stack.peek())) {``                    ``// peek() inbuilt stack function to``                    ``// fetch the top element(token)` `                    ``output += stack.pop();``                ``}``                ``stack.push(c);``            ``}``        ``}` `        ``// pop all the remaining operators from``        ``// the stack and append them to output``        ``while` `(!stack.isEmpty()) {``            ``if` `(stack.peek() == ``'('``)``                ``return` `"This expression is invalid"``;``            ``output += stack.pop();``        ``}``        ``return` `output;``    ``}` `    ``// Main driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Considering random infix string notation``        ``String expression = ``"5+2/(3-8)^5^2"``;` `        ``// Printing RPN for the above infix notation``        ``// Illustrating shunting yard algorithm``        ``System.out.println(infixToRpn(expression));``    ``}``}`

Output
`5238-5^2^/+`
• Time Complexity: O(n) This algorithm takes linear time, as we only traverse through the expression once and pop and push only take O(1).
• Space Complexity: O(n) as we use a stack of size n, where n is length given of expression.

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