Java Program to Implement Shunting Yard Algorithm - GeeksforGeeks

26 Jan, 2022
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
If the value appears next in the expression push the current value in the stack.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.
If the value appears next in the expression push the current value in the stack.
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:
^
3
/
2
*
2
+
1
–
1
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 
Push “(“ onto Stack, and add “)” to the end of AE.Scan AE from left to right and repeat Step 3 to 6 for each element of AE until the Stack is empty.If an operand is encountered, append it to PE.If a left parenthesis is encountered, push it onto Stack.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]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]g×h
Push “(“ onto Stack, and add “)” to the end of AE.
Scan AE from left to right and repeat Step 3 to 6 for each element of AE until the Stack is empty.
If an operand is encountered, append it to PE.
If a left parenthesis is encountered, push it onto Stack.
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]
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]
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 DSimport java.util.Stack;// Importing specific character class as// dealing with only operators and operandsimport 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;    }           // Operator has Left --> Right associativity      static boolean hasLeftAssociativity(char ch) {        if (ch == '+' || ch == '-' || ch == '/' || ch == '*') {            return true;        } else {            return false;        }    }       // 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<Character> 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())                    && hasLeftAssociativity(c)) {                    // 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));    }}
5238-52^^/+

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.
 
clintra
rajeev0719singh
sweetyty
tft035wt51sbq899304l51d13igth0s9g558p7k2
Picked
Technical Scripter 2020
Java
Java Programs
Technical Scripter
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Hashtable in Java
Constructors in Java
Different ways of Reading a text file in Java
Comparator Interface in Java with Examples
Java Math random() method with Examples
Convert a String to Character array in Java
Java Programming Examples
How to Iterate HashMap in Java?
Implementing a Linked List in Java using Class
Min Heap in Java