Infix To Postfix Conversion: Course: Data Structures Course Code: CSE-203

Infix to Postfix
Conversion
Course : Data Structures

Course Code : CSE-203
Infix to Postfix Conversion
 Need to handle operator precedence
 Need to handle parentheses
 Need to handle left-to-right association
 Input: Infix with variables, integers,

operators, parentheses (no
exponentiation for now)
 Output: Postfix form of same expression
Infix Precedence
 Parenthesis ()
 Exponentiation ^
 Multiplication *, Division /
 Addition +, Subtraction -
We will use a stack to convert infix
expression to its equivalent postfix
expression
In computer science
, a stack is an
abstract data type
and data structure
based on the
principle of
Last In First Out (LIFO).
Psuedocode
Get the input of an infix expression into an array
tos=0 (tos=top of the stack)
for (i=0;i<=arraySize;i++)
{
if array[i]is an operand:
Append array[i] to the postfix expression
break;
if array[i]is an operator:
if (tos==0)
push array[i] into the stack
tos++;
if (tos>0)
{
for(j=tos;j>=0;j--){
compare the precedence of array[i] and stack[j];
if array[i] is an operator of greater or equal precedence
pop stack[j] and append it to the postfix expression;
tos--;
else break; }
then push array[i] into the stack
tos++;
break;
}
if array[i] is '(' :
push array[i] into the stack
tos++;
if array[i] is ')' :
for(k=tos;k>=0;k--)
{
if ( stack[k]!=’(’ ) pop stack[k] and append it to the postfix expression;
tos --;
if ( stack==’(’ ) tos --;
break;
}
if array[i]is NULL:
for(l=tos;l>=0;l--)
{
pop stack[l] and append it to the postfix expression;
}
}
Infix input
a*b + (b-c)/g * ( (a+d) * (b-c/f) )
Lets start converting it to its equivalent

postfix
form using a stack.
Infix to postfix conversion
infix expression
a*b + (b-c)/g * ( (a+d) * (b-c/f) )
postfix expression
infix expression
*b + (b-c)/g * ( (a+d) * (b-c/f) )
postfix expression
a
infix expression
b + (b-c)/g * ( (a+d) * (b-c/f) )
postfix expression
a
*
infix expression
+ (b-c)/g * ( (a+d) * (b-c/f) )
postfix expression
ab
*
infix expression
(b-c)/g * ( (a+d) * (b-c/f) )
postfix expression
ab*
+
infix expression
b-c)/g * ( (a+d) * (b-c/f) )
postfix expression
ab*
+
infix expression
-c)/g * ( (a+d) * (b-c/f) )
postfix expression
ab*b
+
infix expression
c)/g * ( (a+d) * (b-c/f) )
postfix expression
ab*b
-
(
+
infix expression
)/g * ( (a+d) * (b-c/f) )
postfix expression
ab*bc
-
(
+
infix expression
/g * ( (a+d) * (b-c/f) )
postfix expression
ab*bc-
+
infix expression
g * ( (a+d) * (b-c/f) )
postfix expression
ab*bc-
/
+
infix expression
* ( (a+d) * (b-c/f) )
postfix expression
ab*bc-g
/
+
infix expression
( (a+d) * (b-c/f) )
postfix expression
ab*bc–g/
*
+
infix expression
(a+d) * (b-c/f) )
postfix expression
ab*bc–g/
(
*
+
infix expression
a+d) * (b-c/f) )
( postfix expression
ab*bc–g/
(
*
+
infix expression
+d) * (b-c/f) )
ab*bc–g/a
(
*
+
infix expression
d) * (b-c/f) )
+
ab*bc–g/a
(
*
+
infix expression
) * (b-c/f) )
+
ab*bc–g/ad
(
*
+
infix expression
* (b-c/f) )
postfix expression
ab*bc–g/ad+
(
*
+
infix expression
(b-c/f) )
* postfix expression
ab*bc–g/ad+
(
*
+
infix expression
b-c/f) )
(
ab*bc–g/ad+
(
*
+
infix expression
-c/f) )
(
ab*bc–g/ad+b
(
*
+
infix expression
- c/f) )
(
ab*bc–g/ad+b
(
*
+
infix expression
- /f) )
(
ab*bc–g/ad+bc
(
*
+
/
infix expression
- f) )
(
ab*bc–g/ad+bc
(
*
+
/
infix expression
- ))
(
ab*bc–g/ad+bcf
(
*
+
infix expression
)
ab*bc–g/ad+bcf/-
(
*
+
infix expression
postfix expression
ab*bc–g/ad+bcf/-*
*
+
infix expression
postfix expression
ab*bc–g/ad+bcf/-**
+
infix expression
postfix expression
ab*bc–g/ad+bcf/-**+
Equivalent postfix
expression
ab*bc–g/ad+bcf/-**+
We have observed
 When we get any integer or character it goes to the output.
The order of the operands in the postfix expression is the same as
the order in the infix expression, and the operands that appear to the
left of an operator in the infix expression also appear to its left in the
postfix expression.
 When we get an operator, it is pushed onto the stack maintaining the

following rule
if the stack is empty, the operator is pushed onto the stack. However,
if the stack is not empty, at first we pop the operators of greater or
equal precedence from the stack and append them to postfix
expression. Then the new operator is pushed onto the stack. Thus,
this step orders the operators by precedence and in accordance with
left-to-right association.
We have observed
 After getting a left parenthesis ‘(‘ , 1 & 2 is maintained until we
get right parenthesis ‘)’. When ")" is encountered, we pop
operators off the stack and append them to the end of postfix
expression until we encounter the matching "(".
Within a pair of parentheses, precedence and left-to-right
association determine the order of the operators.
 When we reach the end of the string, we append the remaining

contents of the stack to postfix expression.
And finally we get the postfix expression.

Thanks to……..
Course teacher:
Abul Hasan Samee
Made by……
Sabrina Hossain Tonny

Roll : 200614033
CSE-7
MIST

Infix To Postfix Conversion: Course: Data Structures Course Code: CSE-203

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Infix To Postfix Conversion: Course: Data Structures Course Code: CSE-203

Uploaded by

Copyright:

Available Formats

Infix to Postfix

Course : Data Structures

 Input: Infix with variables, integers,

ab + (b-c)/g ( (a+d) * (b-c/f) )

Lets start converting it to its equivalent

 When we get an operator, it is pushed onto the stack maintaining the

 When we reach the end of the string, we append the remaining

And finally we get the postfix expression.

Sabrina Hossain Tonny

You might also like