stack and queue

Stack and QueueCSC 391

Fundamental data types.

Value: collection of objects.Operations: insert, remove, iterate, test if empty.

Stack and Queue

Stack. Examine the item most recently added.Queue. Examine the item least recently added.

LIFO = "last in first out“

FIFO = "first in first out"

Stack operation

Stack algorithm

Maintain pointer first to first node in a singly-linked list.

Push new item before first.

Pop item from first.

Stack: linked-list implementation

inner classprivate class Node{String item;Node next;}

Stack: linked-list implementation

Stack : PUSH()

Stack : POP()

Fixed-capacity stack: array implementationUse array s[] to store N items on stack.

push(): add new item at s[N].

pop(): remove item from s[N-1].Defect. Stack overflows when N exceeds capacity.

Fixed-capacity stack: array implementation

Queue: Implementation

Maintain one pointer first to first node in a singly-linked list.

Maintain another pointer last to last node.

Dequeue from first.

Enqueue after last.

Queue algorithm

Queue operation

Enqueue

Queue: Implementati

on

Application

Parsing in a compiler.Undo in a word processor.Back button in a Web browser.PostScript language for printers.Implementing function calls in a compiler.Parsing code:Matching parenthesisXML (e.g., XHTML)Reverse-Polish calculatorsAssembly language

Goal. Evaluate infix expressions.

Polish notation

Infix notation : a + bPrefix notation : + a bPostfix notation: a b + (Reverse Polish Notation)

Prefix notation was introduced by the Polish logician Lukasiewicz, and is sometimes called “Polish notation”.

Postfix notation is sometimes called “reverse Polish notation” or RPN.

infix postfix prefix(a + b) * c a b + c * * + a b ca + (b * c) a b c * + + a * b c

Infix form : <identifier> <operator> <identifier>Postfix form : <identifier> <identifier> <operator> Prefix form : <operator> <identifier> <identifier>

Token Operator Precedence Association

( ) [ ] -> .

function call array element struct or union member

17 left-to-right

-- ++ increment, decrement2 16 left-to-right

-- ++ ! - - + & * sizeof

decrement, increment3

logical not one’s complement unary minus or plus address or indirection size (in bytes)

15 right-to-left

(type) type cast 14 right-to-left

* / % mutiplicative 13 Left-to-right

Operator Precedence

Operator Precedence

+ - 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

Operator Precedence

?: conditional 3 right-to-left

= += -= /= *= %= <<= >>= &= ^= =

assignment

2 right-to-left

, comma

1 left-to-right

Prefix operation using stack

Infix to Prefix Conversion Move each operator to the left of its operands & remove the parentheses:

( ( A + B) * ( C + D ) )

( + A B * ( C + D ) )

* + A B ( C + D )

* + A B + C D

Infix Stack Prefix Operation( ( ( A + B ) * ( C - E ) ) / ( F + G ) ) ---- ---- ----

( ( A + B ) * ( C - E ) ) / ( F + G ) ) ( ----- push

( A + B ) * ( C - E ) ) / ( F + G ) ) (( ---- push

A + B ) * ( C - E ) ) / ( F + G ) ) ((( ---- push

+ B ) * ( C - E ) ) / ( F + G ) ) ((( A output

B ) * ( C - E ) ) / ( F + G ) ) (((+ A push

) * ( C - E ) ) / ( F + G ) ) (((+ AB output

* ( C - E ) ) / ( F + G ) ) (( AB+ pop

( C - E ) ) / ( F + G ) ) ((* AB+ push

C - E ) ) / ( F + G ) ) ((*( AB+ push

- E ) ) / ( F + G ) ) ((*( AB+C output

E ) ) / ( F + G ) ) ((*(- AB+C push

) ) / ( F + G ) ) ((*(- AB+CE output


Infix Stack Prefix Operation) / ( F + G ) ) ((* AB+CE- pop

/ ( F + G ) ) ( AB+CE-* pop

( F + G ) ) (/ AB+CE-* push

F + G ) ) (/( AB+CE-* push

+ G ) ) (/( AB+CE-*F output

G ) ) (/(+ AB+CE-*F push

)) (/(+ AB+CE-*FG output

) (/ AB+CE-*FG+ pop

---- ---- AB+CE-*FG+/ pop


Postfix operation using stack

Infix Stack Postfix OperationA * (B + C) – D / E ---- ---- ----

* (B + C) – D / E ---- A output

(B + C) – D / E * A push

B + C) – D / E *( A push

+ C) – D / E *( AB output

C) – D / E *(+ AB push

) – D / E *(+ ABC output

– D / E * ABC+ pop

D / E - ABC+* pop and push

/ E - ABC+*D output

E -/ ABC+*D push

----- -/ ABC+*DE output

----- ---- ABC+*DE/- pop

The precedence of operator on the top of Stack ‘*‘ is more than that of Minus. So we pop multiply

Postfix operation using stack

Infix Postfix

2+3*4 a*b+5 (1+2)*7 a*b/c (a/(b-c+d))*(e-a)*c a/b-c+d*e-a*c

234*+ ab*5+ 12+7* ab*c/ abc-d+/ea-*c* ab/c-de*ac*-

Convert from Infix to Prefix and Postfix (Practice)

• x• x + y• (x + y) - z• w * ((x + y) - z)• (2 * a) / ((a + b) * (a - c))

Convert from Postfix to Infix (Practice)

• 3 r -• 1 3 r - +• s t * 1 3 r - + +• v w x y z * - + *

Parsing HTML

HTML is made of nested– opening tags, e.g., <some_identifier>, and– matching closing tags, e.g., </some_identifier>

<html><head><title>Hello</title></head><body>This appears in the browswer.</body>

</html>

</html>

<html>

Parsing HTML

</html>

<html> <head>

Parsing HTML

</html>

<html> <head> <title>

Parsing HTML

</html>

<html> <head>

Parsing HTML

</html>

<html> <body>

Parsing HTML

</html>

<html> <body> 

Parsing HTML

</html>

<html> <body> 

Parsing HTML

</html>

<html> <body> 

Parsing HTML

</html>

<html> <body>

Parsing HTML

</html>

<html>

Parsing HTML

stack and queue

Education