Infix, Prefix, and Postfix Expressions: For simplicity, we will consider algebraic expressions with binary operators +, , *, and

/ only.

Infix Notation: Usual notation in constructing algebraic expression such that operator appears between two operands; it is ambiguous and requires knowledge of operator hierarchy for its evaluation. Parentheses can also be used to override operator hierarchy.

Prefix Notation: A special notation in constructing algebraic expression such that operator appears before its two operands. It is unambiguous and does not require the use of parentheses or any knowledge of operator hierarchy for its evaluation.

Postfix Notation: A special notation in constructing algebraic expression such that operator appears after its two operands. It is unambiguous and does not require the use of parentheses or any knowledge of operator hierarchy for its evaluation.

Example: The infix expression ((ab)/c)*((d+e)f) has the following postfix and prefix expression. Postfix: abc/de+f * Prefix: */abc+def

Evaluating Postfix Expression: scan given postfix expression; for each symbol in postfix if operand then push its value onto a stack S; if operator then { pop operand2; pop operand1; apply operator to compute operand1 op operand2; push result back onto stack S; } return value at top of stack;

Evaluating Prefix Expression: reverse given prefix expression; scan the reversed prefix expression; for each symbol in reversed prefix if operand then push its value onto a stack S; if operator then { pop operand1; pop operand2; apply operator to compute operand1 op operand2; push result back onto stack S; } return value at top of stack;

Infix to Postfix Conversion: given a legal infix string; create an initially empty postfix string; create an initially empty operator stack S; for each symbol ch in the infix string do if ch is an operand then append it to the output postfix string; else if ch == ( then push ch onto stack S; else if S == ) then pop and append operators to output string until the matching ( is encountered; // discard the two parentheses else // ch must be some other operator { while operator stack not empty and precedence(top(S)) precedence(ch) and top(S) != ( do pop operator; append it to the postfix string; end while; push S } end for; while operator stack is not empty do pop operator; append it to the postfix string; endwhile;

Infix to Prefix Conversion: reverse a given legal infix string; create an initially empty reversed prefix string; create an initially empty operator stack S; for each symbol ch in the reversed infix string do if ch is an operand then append it to the output prefix string; else if ch == ) then push ch onto stack S; else if S == ( then pop and append operators to output string until the matching ) is encountered; // discard the two parentheses else // ch must be some other operator { while operator stack not empty and precedence(top(S)) > precedence(ch) and top(S) != ) do pop operator; append it to the reversed prefix string; end while; push S } end for; while operator stack is not empty do pop operator; append it to the reversed prefix string; endwhile; reverse the reversed output prefix string;

Example: 1. Given infix expression: ((ab)/c)*((d+e)f) and its equivalent postfix expression: abc/de+f * Postfix evaluation: ch action a push b push pop operand2 pop operand1 compute and push c push / pop operand2 pop operand1 compute and push d push e push + pop operand2 pop operand1 compute and push f push pop operand2 pop operand1 compute and push * pop operand2 pop operand1 compute and push

operand stack a ab a ab ab c ab (ab)/c (ab)/c d (ab)/c d e (ab)/c d ab)/c (ab)/c (d+e) (ab)/c (d+e) f (ab)/c (d+e) ab)/c (ab)/c (d+e)f (ab)/c ((ab)/c) * ((d+e)f)

2. Given infix expression: ((ab)/c)*((d+e)f) and its equivalent prefix expression: */abc+def Reverse the given prefix expression to get f e d + c b a / * Prefix evaluation: ch action f push e push d push + pop operand1 pop operand2 compute and push pop operand1 pop operand2 compute and push c push b push a push pop operand1 pop operand2 compute and push / pop operand1 pop operand2 compute and push * pop operand1 pop operand2 compute and push

operand stack f fe fed fe f f (d+e) f (d+e)f (d+e)f c (d+e)f c b (d+e)f c b a (d+e)f c b (d+e)f c (d+e)f c (ab) (d+e)f c (d+e)f (d+e)f (ab)/c (d+e)f ((ab)/c)* ((d+e)f)

3. Given infix expression: (ab)/c*(d + e f / g). Input: (ab)/c*(d + e f / g) Postfix conversion: ch action operator stack ( push ( a output ( push ( b output ( ) pop until ( / push / c output / * pop push * ( push *( d output *( + push *(+ e output *(+ pop *( push *( f output *( / push *( / g output *( / ) pop until ( * pop until empty stack

Postfix a a ab ab ab abc abc/ abc/ abc/d abc/d abc/de abc/de+ abc/de+ abc/de+f abc/de+f abc/de+fg abc/de+fg/ abc/de+fg/*

Postfix:

abc/de+fg/*

4. Given infix expression: (ab)/c*(d + e f / g). Input: ) g / f e + d ( * c / ) b a ( Prefix conversion: ch action operator stack ) push ) g output ) / push )/ f output )/ pop ) push ) e output ) + push )+ d output )+ ( pop until ) * push * c output * / push */ ) push */) b output */) push */) a output */) ( pop until ) */ pop until empty stack

Reversed Prefix g g gf gf/ gf/ gf/e gf/e gf/ed gf/ed+ gf/ed+ gf/ed+c gf/ed+c gf/ed+c gf/ed+cb gf/ed+cb gf/ed+cba gf/ed+cba gf/ed+cba/*

Prefix: * / a b c + d e / f g