Shunting-yard algorithm

From Wikipedia, the free encyclopedia

In computer science, the shunting-yard algorithm is a method for parsing mathematical expressions specified
in infix notation. It can produce either a postfix notation string, also known as Reverse Polish notation (RPN),
or an abstract syntax tree (AST). The algorithm was invented by Edsger Dijkstra and named the "shunting
yard" algorithm because its operation resembles that of a railroad shunting yard. Dijkstra first described the
Shunting Yard Algorithm in the Mathematisch Centrum report MR 34/61.

Like the evaluation of RPN, the shunting yard algorithm is stack-based. Infix expressions are the form of
mathematical notation most people are used to, for instance "3 + 4" or "3 + 4 (2 1)". For the conversion
there are two text variables (strings), the input and the output. There is also a stack that holds operators not yet
added to the output queue. To convert, the program reads each symbol in order and does something based on
that symbol. The result for the above examples would be "3 4 +" or "3 4 2 1 +".

The shunting-yard algorithm was later generalized into operator-precedence parsing.

Contents
1 A simple conversion
2 Graphical illustration
3 The algorithm in detail
4 Detailed example
5 See also
6 External links

A simple conversion
Input: 3 + 4

1. Push 3 to the output queue (whenever a number is read it is pushed to the output)
2. Push + (or its ID) onto the operator stack
3. Push 4 to the output queue
4. After reading the expression, pop the operators off the stack and add them to the output.

In this case there is only one, "+".

5. Output: 3 4 +

This already shows a couple of rules:

All numbers are pushed to the output when they are read.
At the end of reading the expression, pop all operators off the stack and onto the output.

Graphical illustration
Graphical illustration of algorithm, using a three-way railroad junction. The input is processed one symbol at a
time: if a variable or number is found, it is copied directly to the output a), c), e), h). If the symbol is an
operator, it is pushed onto the operator stack b), d), f). If the operator's precedence is less than that of the
operators at the top of the stack or the precedences are equal and the operator is left associative, then that
operator is popped off the stack and added to the output g). Finally, any remaining operators are popped off the
stack and added to the output i).

The algorithm in detail

Important terms: Token, Function, Operator associativity, Precedence

while there are tokens to be read:

read a token.
if the token is a number , then push it to the output queue.
if the token is an operator , then:
while there is an operator at the top of the operator stack with
greater than or equal to precedence and the operator is left associative :
pop operators from the operator stack, onto the output queue.
push the read operator onto the operator stack.
if the token is a left bracket (i.e. "("), then:
push it onto the operator stack.
if the token is a right bracket (i.e. ")"), then:
while the operator at the top of the operator stack is not a left bracket :
pop operators from the operator stack onto the output queue.
pop the left bracket from the stack.
/* if the stack runs out without finding a left bracket, then there are
mismatched parentheses. */
if there are no more tokens to read:
while there are still operator tokens on the stack:
/* if the operator token on the top of the stack is a bracket, then
there are mismatched parentheses. */
pop the operator onto the output queue.
exit.
To analyze the running time complexity of this algorithm, one has only to note that each token will be read
once, each number, function, or operator will be printed once, and each function, operator, or parenthesis will
be pushed onto the stack and popped off the stack oncetherefore, there are at most a constant number of
operations executed per token, and the running time is thus O(n)linear in the size of the input.

The shunting yard algorithm can also be applied to produce prefix notation (also known as Polish notation). To
do this one would simply start from the end of a string of tokens to be parsed and work backwards, reverse the
output queue (therefore making the output queue an output stack), and flip the left and right parenthesis
behavior (remembering that the now-left parenthesis behavior should pop until it finds a now-right parenthesis).

Detailed example
Input: 3 + 4 2 ( 1 5 ) ^ 2 ^ 3

operator precedence associativity

^ 4 Right

3 Left

3 Left

+ 2 Left

2 Left

The symbol ^ represents the power operator.

Output Operator
Token Action Notes
(in RPN) stack

3 Add token to output 3

+ Push token to stack 3 +

4 Add token to output 34 +

Push token to stack 34 + has higher precedence than +

2 Add token to output 342 +

Pop stack to output 342 + and have same precedence

Push token to stack 342 + has higher precedence than +

( Push token to stack 342 (+

1 Add token to output 3421 (+

Push token to stack 3421 (+

5 Add token to output 34215 (+

Pop stack to output 34215 (+ Repeated until "(" found

)
Pop stack 34215 + Discard matching parenthesis

^ Push token to stack 34215 ^+ ^ has higher precedence than

2 Add token to output 342152 ^+

^ Push token to stack 342152 ^^+ ^ is evaluated right-to-left

3 Add token to output 3421523 ^^+

end Pop entire stack to output 3421523^^+

Input: sin ( max ( 2, 3 ) 3 3.1415 )

Output = Operator
Token Action Notes
(in RPN) stack

sin Push token to stack sin

max Push token to stack max sin

2 Add token to output 2 max sin

3 Add token to output 23 max sin

Pop stack to output 2 3 max sin

Push token to stack 2 3 max sin

3 Add token to output 2 3 max 3 sin

Pop stack to output 2 3 max 3 sin

Push token to stack 2 3 max 3 sin

3.1415 Add token to output 2 3 max 3 3.1415 sin

end Pop entire stack to output 2 3 max 3 3.1415 sin

See also
Operator-precedence parser
Stack-sortable permutation

External links
Dijkstra's original description of the Shunting yard algorithm
Literate Programs implementation in C
Implementation in various languages, including C and Python
Java Applet demonstrating the Shunting yard algorithm
Silverlight widget demonstrating the Shunting yard algorithm and evaluation of arithmetic expressions
Parsing Expressions by Recursive Descent Theodore Norvell 19992001. Access date September 14,
2006.

Retrieved from "https://en.wikipedia.org/w/index.php?title=Shunting-yard_algorithm&oldid=793786890"

This page was last edited on 3 August 2017, at 23:15.

Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may
apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia is a registered
trademark of the Wikimedia Foundation, Inc., a non-profit organization.