Infix prefix postfix

Infix, Postfix and Prefix
Unit 1.3

Infix, Postfix and Prefix
• 2+3 <operand><operator><operand>
• A-b
• (P*2)
Operands are basic objects on which operation is performed
INFIX
<operand><operator><operand>
• (2+3) * 4 (2+3) * 4
• (P+Q)*(R+S) (P+Q) * (R+S)
Common expressions

Infix
• What about 4+6*2 and what about 4+6+2
• To clear ambiguity we remember school Mathematics
• Order of precedence
1. Parentheses (Brackets)
2. Order (Exponents)
3. Division
4. Multiplication
5. Addition
6. Subtraction
• So 4+6*2 | 2*6/2 -3 +7 | {(2*6)/2}-(3+7)
=4+12 | = 2*3-3+7 | = ???
=16 | = 6-3+7 | = ??
| = 3+7=10 | = ?

Prefix (polish notation)
• In prefix notation the operator proceeds the two operands. i.e.
the operator is written before the operands.
<operator><operand><operand>
infix prefix
2+3 +23
p-q -pq
a+b*c +a*bc

Postfix (Reverse Polish Notation)
• In postfix notation the operators are written after the operands
so it is called the postfix notation (post means after).
<operand><operand><operator>
infix prefix postfix
2+3 +23 23+
p-q -pq pq-
a+b*c +a*bc abc*+
Human-readable Good for machines

Conversion of Infix to Postfix Expression
• While evaluating an infix expression, there is an evaluation order according
to which the operations are executed
• Brackets or Parentheses
• Exponentiation
• Multiplication or Division
• Addition or Subtraction
• The operators with same priority are evaluated from left to right.
• Eg:
• A+B+C means (A+B)+C

Evaluation of Postfix Expressions
• Suppose an expression
a*b+c*d-e
• We can write this as:
{(a*b)+(c*d)}-e
• As we want to change it into postfix expression
{(ab*)+(cd*)}-e
{(ab*)(cd*)+}-e
{(ab*)(cd*)+} e-
• Final form
ab*cd*+e-

• Suppose we have a postfix expression
ab*cd*+e-
• And we want to evaluate it so lets say
a=2, b=3,c=5,d=4,e=9
• We can solve this as,
2 3 * 5 4 * + 9 – <operand><operand><operator>
6 5 4 * + 9 –
6 20 + 9 –
26 9 –
17

• From above we get,
2 3 * 5 4 * + 9 –
Stack
EvaluatePostfix(exp)
{
create a stack S
for i=0 to length (exp) -1
{
if (exp[i] is operand)
PUSH(exp[i])
elseif (exp[i] is operator)
op2 <- pop()
op1 <- pop()
res– Perform(exp[i],op1,op2)
PUSH(res)
}
return top of STACK
}
2
3

Evaluation of Prefix expressions
• An expression: 2*3 +5*4-9
• Can be written as:
{(2*3)+(5*4)}-9
{(*2 3)+(*5 4)}-9
{+(*2 3) (*5 4)}-9
-{+(*2 3) (*5 4)}9
• We can get Rid of Paranthesis
-+*2 3 *5 4 9

Evaluation of Prefix expressions
• We have to scan it from right
-+*2 3 *5 4 9
Stack
9
4
5
Stack
9
20
6
Stack
9
26
Stack
17

Algorithm to convert Infix to Postfix

Examples:
1. A * B + C becomes A B * C +
NOTE:
• When the '+' is read, it has lower precedence than the '*', so the '*' must be
printed first.
current symbol Opstack Poststack
A A
* * A
B * AB
+ + AB* {pop and print the '*' before pushing the '+'}
C + AB*C
AB*C+

Examples:
2. A * (B + C) becomes A B C + *
NOTE:
1.Since expressions in parentheses must be done first, everything on the stack is saved and the
left parenthesis is pushed to provide a marker.
2.When the next operator is read, the stack is treated as though it were empty and the new
operator (here the '+' sign) is pushed on.
3.Then when the right parenthesis is read, the stack is popped until the corresponding left
parenthesis is found.
4.Since postfix expressions have no parentheses, the parentheses are not printed.
current symbol Opstack Poststack
A A
* * A
( *( A
B *( AB
+ *(+ AB
C *(+ ABC
) * ABC+
ABC+*

Recursion
• Recursion is a process by which a function calls itself
repeatedly, until some specified condition has been satisfied
• The process is used for repetitive computations in which each
action is stated in terms of a previous result.
• To solve a problem recursively, two conditions must be
satisfied.
• First, the problem must be written in a recursive form
• Second the problem statement must include a stopping condition

Factorial of an integer number using recursive
function
void main(){
int n;
long int facto;
scanf(“%d”,&n);
facto=factorial(n);
printf(“%d!=%ld”,n,facto);
}
long int factorial(int n){
if(n==0){
return 1;
}else{
return n*factorial(n-1);
}
Factorial(5)=
5*Factorial(4)=
5*(4*Factorial(3))=
5*(4*(3*Factorial(2)))=
5*(4*(3*(2*Factorial(1))))=
5*(4*(3*(2*(1*Factorial(0)))))=
5*(4*(3*(2*(1*1))))= 5*(4*(3*(2*1)))=
5*(4*(3*2))= 5*(4*6)= 5*24=
120

Recursion Pros and Cons
• Pros
• The code may be much easier to write.
• To solve some problems which are naturally recursive such as tower of
Hanoi.
• Cons
• Recursive functions are generally slower than non-recursive functions.
• May require a lot of memory to hold intermediate results on the system
stack.
• It is difficult to think recursively so one must be very careful when
writing recursive functions.

Tower of Hanoi Problem
• The mission is to move all the disks to some another tower
without violating the sequence of arrangement.
• The below mentioned are few rules which are to be followed for
tower of hanoi −
• Only one disk can be moved among the towers at any given time.
• Only the "top" disk can be removed.
• No large disk can sit over a small disk.

A recursive algorithm for Tower of Hanoi can be driven as follows −

Infix prefix postfix

Recommended

More Related Content

What's hot (20)

Similar to Infix prefix postfix (20)

More from Self-Employed (7)

Recently uploaded (20)

Infix prefix postfix