Data Structures*

• Example: Sorting elements

– Input: a set S of numbers
Introduction to Computers and – Output: elements of S in increasing order
Programming
– Algorithm:
Prof. I. K. Lundqvist 1. Locate smallest item in S
2. Output smallest item
3. Delete smallest item from S
4. GOTO 1, while S ≠∅

Key to a good solution: data structure for S

Lecture 4
Mar 17 2004

Topics for next 5 lectures Stacks and Queues

• Elementary data structures • Dynamic sets in which the element

– Stacks and Queues removed from the set by the Delete
– Linked lists
operation is prespecified.
– Graphs
– Trees
• STACK
– Element deleted is: most recently inserted
element
•Today:
–Stacks and Queues • QUEUE
– Element deleted is: element that has been
–FIFO vs. LIFO
in the set the longest
–Implementations using arrays
–Expression Conversion
 Stack Stack
• Stack: A list with insertion and deletion
both take place at one end: the top
– Main operations • Example use of stacks:
• Push
– New item added on top of stack, size of stack increases
by one
• Pop
– Top-item removed from stack, decreasing stack size by
one
– Other operations
• Initialize, Empty, Size, Top, Stack_Top, Display, … • Implementations used:
– Arrays or linked lists
• Implements a LIFO policy
– New addition makes older items inaccessible

Implementing Stack using Array Empty(S)

1 2 3 4 5 6 7 8 9 10
S 5 3 12 0 42 if top[S]=1 then
Top[S]=6 return true
else
1 2 3 4 5 6 7 8 9 10
S 5 3 12 0 42 17 2 return false
Top[S]=8

1 2 3 4 5 6 7 8 9 10
S 5 3 12 0 42 17 2

Top[S]=7
 Push (S, x) Pop (S)

if STACK-FULL(S) then if STACK-EMPTY(S) then

error “overflow” error “underflow”
else else
S[top[S]] := x top[S] := top[S]-1
top[S] := top[S]+1 return S[top[S]]

my_stack.ads
my_stack.adb
test_stack.adb

Performance and Limitations

Queue
of My_Stack

• Performance • A list of elements with

– Let N be the number of elements in the – Insertion: at end of list, tail
stack
– Deletion: at start of list, head
– The space used is O(N)
– Each operation used is O(1)
• Implements a FIFO policy
• Limitations – Queues are fair when someone has to wait
– The maximum size of the stack must be
defined a priori and cannot be changed • Examples:
– Trying to push a new element into a full
stack causes an implementation-specific
exception
 Implementing a Queue
ENQUEUE (Q, x)
using an Array Q[1..12]
1 2 3 4 5 6 7 8 9 10 11 12
Q 5 3 12 0 42 7

head[Q]=6 tail[Q]=12 Q[tail[Q]] := x

if tail[Q] = length[Q] then
1 2 3 4 5 6 7 8 9 10 11 12
Q 67 5 3 12 0 42 7 3
tail[Q] := 1
else
tail[Q]=2 head[Q]=6 “wrap around”
(location 1 is immediately following location n) tail[Q] := tail[Q]+1

1 2 3 4 5 6 7 8 9 10 11 12
Q 67 5 3 12 0 42 7 3

tail[Q]=2 head[Q]=5

DEQUEUE (Q) Operations on Queues

x := Q[head[Q]]
if head[Q] = length[Q] then • Create, Enqueue, Dequeue, Size,
head[Q] := 1 Is_Empty, Is_Full, Display
else
head[Q] :=head[Q]+1
return x

Exercise: Update my_queue to make it

a circular queue my_queue.ads
my_queue.adb
test_queue.adb
 Examples Using Stacks Infix vs. Postfix

• Infix vs. postfix Infix Expressions Corresponding Postfix

– How to evaluate postfix
5+3+4+1 53+4+1+
– How to evaluate infix
(5 + 3) * 10 5 3 + 10 *

(5 + 3) * (10 – 4) 5 3 10 4 - *
• Convert Infix to Postfix
5 * 3 / (7 – 8) 53*78-/

(b * b – 4 * a * c) / (2 * a) bb*4a*c*-2a*/

my_expression_converter.ads
my_expression_converter.adb
converter_test.adb
[use these for this weeks PSET]

How to Evaluate Postfix Evaluating infix expressions

• Need two stacks, one for numbers and one
A program can evaluate postfix expressions
for operators
by reading the expression from left to right
for I in 1 .. length loop
If Is_Number(expr(I)) = true then
for I in 1 .. length loop push expr(I) onto operand_stack
If Is_Number(expr(I)) = true then If Is_Operator(expr(I)) then
push expr(I) push expr(I) onto operator_stack
If Is_Operator(expr(I)) then If expr(I) = ‘)’ then
pop two numbers from the stack pop 2 numbers from operand_stack
perform operation pop an operator from the operator_stack
push result onto stack perform operation
end loop push the result onto the operand_stack
-- result is on top of stack end loop
-- The top of stack contains the result.
How is a bad postfix expression indicated?
 Infix to Postfix: Example Infix to Postfix
• Infix Expression
post_fix := “”
3 + 5 * 6 – 7 * (8 + 5)
Create(Op_Stack)
for I in 1 .. Length loop
• Postfix Expression
If Is_Operand(expr(I)) = true then
3 5 6 * + 7 8 5 + *–
Append(post_fix, expr(I))

If Is_Operator(expr(I)) = true then

Process_Next_Operator(expr(I))
end loop
-- string post_fix has the result

Process_Next_Operator
Done := False
loop
If Is_Empty(Op_Stack) or next_op is ‘(‘,
push next_op onto Op_Stack
set Done to True
Elsif precedence(next_op) > precedence(top_operator)
Push next_op onto Op_stack
-- ensures higher precedence operators evaluated first
Set Done to True
Else
Pop the operator_stack
If operator popped is ‘(‘
set Done to True
Else
append operator popped to post_fix string
exit when Done = True
end loop