Shunting yard algorithm

The shunting yard algorithm is mainly used for parsing mathematical expressions specified in infix notation. It produces the postfix notation. That means this algorithm is used to convert the infix notation to RPN. The postfix notation is also known as the reverse polish notation (RPN).

Edsger Dijkstra developed this algorithm. The algorithm was named "shunting yard" because its activity resembles a railroad shunting yard.

It is a stack-based algorithm. This algorithm was later generalized to operator-precedence parsing. The input of this algorithm is divided into two parts: the output queue and the operator stack, as shown in the examples below.

The form of infix notation expressions is "7 + 5" or 7 + 5 * (8 - 5) and the form of the reverse polish notation expressions is "7 5 +" or "7 5 8 5 - * +".

Precedence Table

Symbol	Precedence	Value
^	High	3
/	Less than ^	2
*	Equal of /	2
+	Low	1
-	Equal of +	1

Example 1: Simple conversion of the infix notation to postfix notation "5 + 8".

Step 1: Input "5 + 8"

Step 2: Push 5 to the output queue

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

Step 4: Push 8 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 "5 8 +"

Example 2: Convert infix notation to reverser polish notation.

Input: A + B - C * D + (E ^ F) * G / H + I

Symbols	Action	Stack	Output	Note
A	"A" add token to output		A
+	Push token to stack	+	A
B	"B" add token to output	+	A B
-	Pop stack to output		A B +	+ and - have same precedence
	Now, - push token to stack	-	A B +
C	"C" add token to output	-	A B + C
*	Push token to stack	-*	A B + C	* has higher precedence than -
D	"D" add token to output	-*	A B + C D
+	Pop stack to output	-	A B + C D *	+ has lesser precedence than *
	Pop stack to output		A B + C D * -	+ and - have same precedence
	Now, + push token to stack	+	A B + C D * -
(	Push token to stack	+(	A B + C D * -
E	"E" add token to output	+(	A B + C D * - E
^	Push token to stack	+(^	A B + C D * - E
F	"F" add token to output	+(^	A B + C D * - E F
)	Pop stack to output	+	A B + C D * - E F ^	Discard bracket
*	Push token to stack	+*	A B + C D * - E F ^	* has higher precedence than +
G	"G" add token to output	+*	A B + C D * - E F ^ G
/	Pop stack to output	+	A B + C D * - E F ^ G *	/ and * have same precedence
	Now, push token to stack	+/	A B + C D * - E F ^ G *
H	"H" add token to output	+/	A B + C D * - E F ^ G * H
+	Pop stack to output	+	A B + C D * - E F ^ G * H /	+ has lesser precedence than /
	Pop stack to output		A B + C D * - E F ^ G * H / +	Same precedence
	Now, Push token to stack	+	A B + C D * - E F ^ G * H / +
I	"I" add token to output	+	A B + C D * - E F ^ G * H / + I
End	Pop whole stack		A B + C D * - E F ^ G * H / + I +

Output: A B + C D * - E F ^ G * H / + I +

Example 3: Convert infix notation to reverser polish notation.

Input: 4 + 2 / (9 - 8) ^ 4 ^ 2

Symbols	Action	Stack	Output	Note
4	"4" add token to output		4
+	Push token to stack	+	4
2	"2" add token to output	+	4 2
/	Push token to stack	+ /	4 2	/ has higher precedence than +
(	Push token to stack	+ / (	4 2
9	"9" add token to output	+ / (	4 2 9
-	Push token to stack	+ / ( -	4 2 9
8	"8" add token to output	+ / ( -	4 2 9 8
)	Pop stack to output	+ /	4 2 9 8 -	Discard bracket
^	Push token to stack	+ / ^	4 2 9 8 -	^ has higher precedence than /
4	"4" add token to output	+ / ^	4 2 9 8 - 4
^	Push token to stack	+ / ^ ^	4 2 9 8 - 4	^ is evaluated right to left
2	"2" add token to output	+ / ^ ^	4 2 9 8 - 4 2
End	Pop whole stack		4 2 9 8 - 4 2 ^ ^ / +

Output: 4 2 9 8 - 4 2 ^ ^ / +

Implementation of shunting yard algorithm in Java

/**
 ** Implement Shunting Yard Algorithm in Java language
 **/
 
import java.util.Scanner;
 
/** Class AlgShuntingYard **/
public class AlgShuntingYard
{
    /** flag **/
    private flag Precedence
    {
        leftparen(0), rightparen(1), nplus(2), nminus(3), ndivide(4), times(5), nmod(6), neos(7), operand(8);

   /** Alg of Shunting.Yard **/
 
        private int index;
        Precedence (int index)
        {
            this.index = index;
        }
        public int getIndex()
        {
            return index;
        }        
    } 

    private static final int[] isp = {10, 20, 11, 32, 25, 23, 21, 12, 1.5};
    private static final int[] icp = {10, 20, 11, 32, 25, 23, 21, 12, 1.5};
    private static final char[] operators = {'{', '}', '+', '-', '/', '*', '%', ' '};
    private Precedence[] stack; 
    private int top;
    private Precedence pop()
    {
        return stack[top--];
    }
    private void push(Precedence ele)
    {
        stack[++top] = ele;
    }
    
    public Precedence getToken(char sign)
    {
        switch (sign)
        {
        case '('  : return Precedence.leftparen;
        case ')'  : return Precedence.rightparen;
        case '+'  : return Precedence.nplus;
        case '-'  : return Precedence.nminus;
        case '/'  : return Precedence.ndivide;
        case '*'  : return Precedence.times;
        case '%'  : return Precedence.nmod;
        case ' '  : return Precedence.neos;
        default   : return Precedence.operand;
        }
    }
 
    /** conversation of infix to postfix expression **/
    public String postfix(String infix)
    {
        String postfix = "";
        top = 0;
        stack = new Precedence[infix.length()];
        stack[0] = Precedence.neos;
        Precedence token;
        for (int z = 0; z < infix.length(); z++)
        {
            token = getToken(infix.charAt(z));
          
            if (token == Precedence.operand)
                postfix = postfix + infix.charAt(z);

            /**. If the token is the proper pop parenthesis before the left parenthesis matches. **/
            else if (token == Precedence.rightparen)
            {
                while (stack[top] != Precedence.leftparen)
                    postfix = postfix + operators[pop().getIndex()];

                /** discard.the left parenthesis **/
                pop();
            }
          
            else
            {
                while (isp[stack[top].getIndex()] >= icp[token.getIndex()])
                    postfix = postfix + operators[pop().getIndex()];
                push(token);
            }
        }
        /** pop elements remaining. **/
        while ((token = pop()) != Precedence.neos)
            postfix = postfix + operators[token.getIndex()];
 
        return postfix;
    }
   
      /** Main function of the program. **/
    public static void main (String[] args) 
    {
        Scanner scan = new Scanner(System.in);
        System.out.println("Try to Shunting Yard Algorithm \n");
      
        AlgShuntingYard sy = new AlgShuntingYard();
 
        /** Take infix expression **/
        System.out.println("Enter infix expression");
        String infix = scan.next();
 
        String postfix = sy.postfix(infix);
        System.out.println("\n Reverse_Polish_expression. : "+ postfix);
    }
}

Next TopicJava Destructor

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

Javatpoint Services

JavaTpoint offers too many high quality services. Mail us on h[email protected], to get more information about given services.

Website Designing
Website Development
Java Development
PHP Development
WordPress
Graphic Designing
Logo
Digital Marketing
On Page and Off Page SEO
PPC
Content Development
Corporate Training
Classroom and Online Training
Data Entry

Training For College Campus

JavaTpoint offers college campus training on Core Java, Advance Java, .Net, Android, Hadoop, PHP, Web Technology and Python. Please mail your requirement at [email protected].
Duration: 1 week to 2 week

^{Like/Subscribe us for latest updates or newsletter}