Scribd
Upload
68 views

CSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea

The document discusses infix to postfix conversion of mathematical expressions. It provides an algorithm that uses a stack to process tokens from an infix expression and output an equivalent postfix expression. The algorithm pops operators from the stack when their precedence is higher than the incoming operator, and otherwise pushes operators onto the stack. It also handles parentheses matching. Pseudocode is presented to implement the algorithm.

Uploaded by

Vicky Butt
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
68 views

CSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea

The document discusses infix to postfix conversion of mathematical expressions. It provides an algorithm that uses a stack to process tokens from an infix expression and output an equivalent postfix expression. The algorithm pops operators from the stack when their precedence is higher than the incoming operator, and otherwise pushes operators onto the stack. It also handles parentheses matching. Pseudocode is presented to implement the algorithm.

Uploaded by

Vicky Butt
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 20

CSCE 3110

Data Structures &


Algorithm Analysis

Rada Mihalcea
http://www.cs.unt.edu/~rada/CSCE3110

Stack Applications
Reading: Chap. 3 Weiss
Applications

Infix to Postfix conversion


[Evaluation of Expressions]
Evaluation of Expressions
X=a/b-c+d*e-a*c

a = 4, b = c = 2, d = e = 3

Interpretation 1:
((4/2)-2)+(3*3)-(4*2)=0 + 8+9=1

Interpretation 2:
(4/(2-2+3))*(3-4)*2=(4/3)*(-1)*2=-2.66666…

How to generate the machine instructions correspo


nding to a given expression?
precedence rule + associative rule
Token Operator Precedence1 Associativity

() function call 17 left-to-right


[] array element
-> . struct or union member
-- ++ increment, decrement2 16 left-to-right

-- ++ decrement, increment3 15 right-to-left


! logical not
- one’s complement
-+ unary minus or plus
&* address or indirection
sizeof size (in bytes)
(type) type cast 14 right-to-left

*/% mutiplicative 13 Left-to-right


+- binary add or subtract 12 left-to-right

<< >> shift 11 left-to-right

> >= relational 10 left-to-right


< <=
== != equality 9 left-to-right

& bitwise and 8 left-to-right

^ bitwise exclusive or 7 left-to-right

bitwise or 6 left-to-right

&& logical and 5 left-to-right

 logical or 4 left-to-right
?: conditional 3 right-to-left

= += -= assignment 2 right-to-left
/= *= %=
<<= >>=
&= ^= =

, comma 1 left-to-right
user compiler

Infix Postfix
2+3*4 234*+
a*b+5 ab*5+
(1+2)*7 12+7*
a*b/c ab*c/
(a/(b-c+d))*(e-a)*c abc-d+/ea-*c*
a/b-c+d*e-a*c ab/c-de*ac*-

Postfix: no parentheses, no precedence


Token Stack Top
[0] [1] [2]
6 6 0
2 6 2 1
/ 6/2 0
3 6/2 3 1
- 6/2-3 0
4 6/2-3 4 1
2 6/2-3 4 2 2
* 6/2-3 4*2 1
+ 6/2-3+4*2 0
Infix to Postfix
Assumptions:
operators: +, -, *, /, %
operands: single digit integer

#define MAX_STACK_SIZE 100 /* maximum stack size */


#define MAX_EXPR_SIZE 100 /* max size of expression */
typedef enum{1paran, rparen, plus, minus, times, divide,
mod, eos, operand} precedence;
int stack[MAX_STACK_SIZE]; /* global stack */
char expr[MAX_EXPR_SIZE]; /* input string */
Evaluation of Postfix Expressions
int eval(void)
{
/* evaluate a postfix expression, expr, maintained as a
global variable, ‘\0’ is the the end of the expression.
The stack and top of the stack are global variables.
get_token is used to return the token type and
the character symbol. Operands are assumed to be single
character digits */
precedence token;
char symbol; int op1, op2;
int n = 0; /* counter for the expression string */
int top = -1;
token = get_token(&symbol, &n);
while (token != eos) {
if (token == operand)
push(&top, symbol-’0’); /* stack insert */
else { /* remove two operands, perform operation, and
return result to the stack */
op2 = pop(&top); /* stack delete */
op1 = pop(&top);
switch(token) {
case plus: push(&top, op1+op2); break;
case minus: push(&top, op1-op2); break;
case times: push(&top, op1*op2); break;
case divide: push(&top, op1/op2); break;
case mod: push(&top, op1%op2);
}
}
token = get_token (&symbol, &n);
}
return pop(&top); /* return result */
}
precedence get_token(char *symbol, int *n)
{
/* get the next token, symbol is the character
representation, which is returned, the token is
represented by its enumerated value, which
is returned in the function name */

*symbol =expr[(*n)++];
switch (*symbol) {
case ‘(‘ : return lparen;
case ’)’ : return rparen;
case ‘+’: return plus;
case ‘-’ : return minus;
case ‘/’ : return divide;
case ‘*’ : return times;
case ‘%’ : return mod;
case ‘\0‘ : return eos;
default : return operand;
/* no error checking, default is operand */
}
}
Infix to Postfix Conversion
(Intuitive Algorithm)
(1) Fully parenthesized expression
a / b - c + d * e - a * c -->
((((a / b) - c) + (d * e)) – (a * c))

(2) All operators replace their corresponding right


parentheses.
((((a / b) - c) + (d * e)) – (a * c))

/ - +* -*
(3) Delete all parentheses.
ab/c-de*+ac*-
two passes
The orders of operands in infix and postfix are the same.
a + b * c, * > +

Token Stack Top Output


[0] [1] [2]
a -1 a
+ + 0 a
b + 0 ab
* + * 1 ab
c + * 1 abc
eos -1 abc*=
a *1 (b +c) *2 d

Token Stack Top Output


[0] [1] [2]
a -1 a
*1 *1 0 a
( *1 ( 1 a
b *1 ( 1 ab
+ *1 ( + 2 ab
c *1 ( + )
match 2 abc
) *1 *1 = *2 0 abc+
*2 *2 0 abc+*1
d *2 0 abc+*1d
eos *2 0 abc+*1d*2
Rules

(1) Operators are taken out of the stack as long as their


in-stack precedence is higher than or equal to the
incoming precedence of the new operator.

(2) ( has low in-stack precedence, and high incoming


precedence.

( ) + - * / % eos
isp 0 19 12 12 13 13 13 0
icp 20 19 12 12 13 13 13 0
precedence stack[MAX_STACK_SIZE];
/* isp and icp arrays -- index is value of precedence
lparen, rparen, plus, minus, times, divide, mod, eos */
static int isp [ ] = {0, 19, 12, 12, 13, 13, 13, 0};
static int icp [ ] = {20, 19, 12, 12, 13, 13, 13, 0};

isp: in-stack precedence


icp: incoming precedence
Infix to Postfix
void postfix(void)
{
/* output the postfix of the expression. The expression
string, the stack, and top are global */
char symbol;
precedence token;
int n = 0;
int top = 0; /* place eos on stack */
stack[0] = eos;
for (token = get _token(&symbol, &n); token != eos;
token = get_token(&symbol, &n)) {
if (token == operand)
printf (“%c”, symbol);
else if (token == rparen ){
Infix to Postfix (cont’d)
/*unstack tokens until left parenthesis */
while (stack[top] != lparen)
print_token(delete(&top));
pop(&top); /*discard the left parenthesis */
}
else{
/* remove and print symbols whose isp is greater
than or equal to the current token’s icp */
while(isp[stack[top]] >= icp[token] )
print_token(delete(&top));
push(&top, token);
}
}
while ((token = pop(&top)) != eos)
print_token(token);
print(“\n”);

You might also like