CSC 172 DATA STRUCTURES

A TALE OF TWO STRUCTURES

STACK – LIFO QUEUE - FIFO

#define MAXVAL 100 int sp = 0; double val[MAXVAL]; void push(double f) { if (sp < MAXVAL) val[sp++] = f; else printf(“error: stack full \n”); } double pop (void) { if (sp > 0) return val[--sp]; else { printf(“error: stack empty\n”); return 0.0; } }

#define MAXVAL 100 double val[MAXVAL]; void enqueue(double f) { #define MAXVAL 100 double val[MAXVAL]; void enqueue(double f) { } double dequeue (void) { }

#define MAXVAL 100 int head = 0 ; tail = 0; double val[MAXVAL]; void enqueue(double f) { if (((head + 1) % MAXVAL) != tail) { val[head] = f; head = (head + 1) % MAXVAL; } else printf(“error: queue full\n”); } double dequeue (void) { if (tail != head) { int temp = tail; tail = (tail + 1 ) % MAXVAL; return val[temp]; } else printf(“error: queue empty\n”); return 0.0 ; }

Stack & Queue with Linked List? What does “push” look like? What does “pop” look like? Queue What kind of linked list? What does enqueue look like? What does dequeus look like?

A useful stack algorithm Postfix evaluation We can rewrite the infix expression 1+2 As the postfix expression 1 2 + “Think” like a computer “load value ‘1’ into accumulator “load value ‘2’ into register A Add value in register A to value in accumulator How about 1+2+3+4 ? How about 2*3+4? How about 2+3*4?

How to implement? Can you write method that evaluates postfix expressions? double postfixeval(Object[] items) Where objects in items[] are either Double Character

Postfix evaluation using a stack Make an empty stack Read tokens until EOF If operand push onto stack If operator Pop two stack values Perform binary operation Push result At EOF, pop final result

Trace by hand 1 2 3 4 + + + 2 3 * 4 + 2 3 4 * +

Infix to postfix 1 + 2 * 3 == 7 (because multiplication has higher precedence) 10 – 4 – 3 == 3 (because subtraction proceeds left to right)

Infix to postfix 4 ^ 3 ^ 2 == 262144 != 4096 Generally, Rather than:

Precedence A few simple rules: ( ) > ^ > * / > + - ( ) > ^ > * / > + - Subtraction associates left-to-right Exponentiation associates right to left

Infix Evaluation 1 – 2 – 4 ^ 5 * 3 * 6 / 7 ^ 2 ^ 2 == -8 (1 – 2) – ( ( ( ( 4 ^ 5) * 3) * 6) / (7 ^ ( 2 ^ 2 ) ) ) Could you write a program to evaluate stuff like this?

Postfix If we expressed (1 – 2) – ( ( ( ( 4 ^ 5) * 3) * 6) / (7 ^ ( 2 ^ 2 ) ) ) As 1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - Then, we could use the postfix stack evaluator

Postfix evaluation using a stack Make an empty stack Read tokens until EOF If operand push onto stack If operator Pop two stack values Perform binary operation Push result At EOF, pop final result

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / -

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 2 1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 4 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 5 4 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 1024 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 3 1024 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 3072 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 6 3072 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 18432 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 7 18432 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 2 7 18432 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 2 7 18432 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 4 7 18432 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 2041 18432 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - 7 -1

1 2 – 4 5 ^ 3 * 6 * 7 2 2 ^ ^ / - -8

But how to go from infix to postfix? Could you write a program to do it? What data structures would you use Stack Queue How about a simple case just using “+” 1+ 2 + 7 + 4 1 2 7 4 + + + Operands send on to output? Operator push on stack? Pop ‘em all at the end?

More complex 2 ^ 5 – 1 == 2 5 ^ 1 – Modify the simple rule? If you are an operator, pop first, then push yourself? 1 + 2 + 7 + 4 1 2 + 7 + 4 + ok

Even more complex 3 * 2 ^ 5 - 1 3 2 5 ^ * 1 – If you are an operator: 3 * 2 ^ 5 - 1 3 2 5 ^ * 1 – If you are an operator: Pop if the top of the stack is higher precedence than

Infix to postfix Stack Algorithm Operands : Send to queue Close parenthesis: Pop stack & send to queue until you find an open parenthesis Operators: Pop all stack symbols and send to queue until a symbol of lower precedence (or a right-associative symbol of equal precedence) appears. Push operator EOF: pop all remaining stack symbols and send to queue

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 1

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 - 1

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 - 1 2

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 ^ - 1 2

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 ^ - 1 2 3

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 ^ - 1 2 3

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 ^ - 1 2 3 3

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 - 1 2 3 3 ^ ^ -

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 ( - 1 2 3 3 ^ ^ -

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 ( - 1 2 3 3 ^ ^ - 4

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 + ( - 1 2 3 3 ^ ^ - 4

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 + ( - 1 2 3 3 ^ ^ - 4 5

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 * + ( - 1 2 3 3 ^ ^ - 4 5

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 * + ( - 1 2 3 3 ^ ^ - 4 5 6

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 - 1 2 3 3 ^ ^ - 4 5 6 * +

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 * - 1 2 3 3 ^ ^ - 4 5 6 * +

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 * - 1 2 3 3 ^ ^ - 4 5 6 * + 7

1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 1 2 3 3 ^ ^ - 4 5 6 * + 7 * -

((1 – (2 ^ (3 ^ 3))) – (( 4 + (5 * 6)) * 7)) 1 – 2 ^ 3 ^ 3 – ( 4 + 5 * 6) * 7 ((1 – (2 ^ (3 ^ 3))) – (( 4 + (5 * 6)) * 7)) To evaluation stack Input 1 2 3 3 ^ ^ - 4 5 6 * + 7 * -