CSE 326
More Lists, Stacks and Queues
David Kaplan
Dept of Computer Science & Engineering
Autumn 2001
Housekeeping
 Project 1 posted, due Fri Oct 19
 Solo project
 Later projects will be done in teams
 Quiz 1 postponed to Mon Oct 15
 Homework 1 due Fri Oct 12
Linear ADTs
CSE 326 Autumn 2001
2
Queue ADT
Queue implements flow-through semantics (FIFO)
 Queue property: if x enters the queue before y, then x will
leave the queue before y
Lots of real-world analogies
 Grocery store line, call center waiting, bank teller line, etc.
class Queue {
void enqueue(object o)
object dequeue()
bool is_empty()
bool is_full()
}
Linear ADTs
CSE 326 Autumn 2001
Enqueue
c b a
Dequeue
c b a
c b a
3
Circular Array Queue
Q
0
size - 1
b c d e f
front
void enqueue(Object x) {
if (is_full()) return
Q[back] = x
back = (back + 1) % size
}
Object dequeue() {
if (is_empty()) return
x = Q[front]
front = (front + 1) % size
return x
}
Linear ADTs
back
bool is_empty() {
return (front == back)
}
bool is_full() {
return front == (back + 1) % size
}
Note robustness checks!!!
CSE 326 Autumn 2001
4
Circular Queue Example
enqueue
enqueue
dequeue
enqueue
enqueue
enqueue
dequeue
dequeue
enqueue
dequeue
Linear ADTs
R
O
T
A
T
E
CSE 326 Autumn 2001
5
Linked List Q Data Structure
b
c
d
front
f
back
void enqueue(Object x) {
if (is_empty())
front = back = new Node(x)
else
back->next = new Node(x)
back = back->next
}
Linear ADTs
e
CSE 326 Autumn 2001
Object dequeue() {
assert(!is_empty)
return_data = front->data
temp = front
front = front->next
delete temp
return temp->data
}
bool is_empty()
{ return front == null }
6
Circular Array vs. Linked List,
Fixed Array vs. Stretchy Array
Array vs. Linked List




Ease of implementation?
Generality?
Speed?
Flexibility?
Fixed Array vs. Stretchy Array
 Ditto?
Linear ADTs
CSE 326 Autumn 2001
7
Queue Application:
Web Services
Web server receives requests over the Internet
 Request, Response Queues are core subsystems of web server
 Listener process enqueues arriving request onto Request
Queue, immediately resumes listening
 Worker process, often running on a separate processor,
dequeues a request, processes it, enqueues result onto
Response Queue
 Responder process dequeues requests from Response Queue
and sends result over the Internet to requestor
requests
The
Web
Linear ADTs
Listener
Request Q
Worker
responses
Responder
CSE 326 Autumn 2001
Response Q
8
Stack ADT
Stack implements push-down semantics (LIFO)
 Stack property: if x is on the stack before y is pushed, then
x will be popped after y is popped
Lots of real-world analogies
 Coin-holder, stack of plates in greasy-spoon diner, RPN
calculator, etc.
class Stack {
void push(object o)
object pop()
object top()
bool is_empty()
bool is_full()
}
Linear ADTs
CSE 326 Autumn 2001
Push
A
Pop
EDCBA
B
C
D
E
F
F
9
Array Stack Data Structure
S
0
size - 1
f e d c b
back
void push(Object x) {
assert(!is_full())
S[back] = x
back++
}
Object top() {
assert(!is_empty())
return S[back - 1]
}
Linear ADTs
Object pop() {
back-return S[back]
}
bool is_empty()
{ return back == 0 }
bool is_full()
{ return back == size }
CSE 326 Autumn 2001
10
Linked List Stack Data Structure
b
c
back
void push(Object x) {
temp = back
back = new Node(x)
back->next = temp
}
Object top() {
assert(!is_empty())
return back->data
}
Linear ADTs
d
e
f
Object pop() {
assert(!is_empty())
return_data = back->data
temp = back
back = back->next
delete temp
return return_data
}
bool is_empty()
{ return back == null }
CSE 326 Autumn 2001
11
Stack Application:
Function Calls
Most recursive languages
implement function calls with a
call stack made up of stack
frames
Scenario:
f1 calls f2, f2 calls f3
f1f2
stack frame
f1 registers
f1 return addr
f1f2 params
f2f3
stack frame
f2 registers
f2 return addr
f2f3 params
Linear ADTs
CSE 326 Autumn 2001
Caller



Callee





Caller



push register contents
push return address
push call parameters
pop call parameters
run local code
pop return address
push return value
return (jump to return address)
pop return value
pop register contents
resume
12
Applications of Linked Lists
Pretty much everything!
 Class list
 Operating systems: list of running programs
 Compilers: list of functions in a program, statements in a
function
 Graphics: list of polygons to be drawn to the screen
 Stacks and Queues: supporting structure
 Probably the most ubiquitous structure in computer science!
Many ADTS such as graphs, relations, sparse matrices,
multivariate polynomials use multiple linked lists
General principle throughout the course
 Use a simpler ADT to implement a more complicated one
Linear ADTs
CSE 326 Autumn 2001
13
Applications of
Multiple-List Data Structures
Higher dimensionality can cause combinatorial explosion
 List sparseness can address this problem
Hence, many high-d applications use multiple linked lists
 graphs (2D)
 relations (multi-D)
 matrices (2-D, usually)
 multivariate polynomials (multi-D)
 radix sort (2-D)
Linear ADTs
CSE 326 Autumn 2001
14
Implementations of
Multiple-List Data Structures
 Array of linked lists
 Linked list of linked lists
 Cross-List
Linear ADTs
CSE 326 Autumn 2001
15
Cross-List
Cross-List has distinguished node types
 Exterior node is an ordinary node
 D different types of exterior node
 Each exterior node type is a dimension
 Interior node contains D next pointers, 1 per dimension
Example: enrollments of students in courses
 35,000 students; 6,000 courses  ~2 million unique combinations
 Array implementation requires 2-million-cell array
 Assume each student takes 5 courses
 Multi-list implementation requires ~200k nodes; 90% space savings
Benefit: efficient storage for sparse lists
Linear ADTs
CSE 326 Autumn 2001
16
Cross-List Application:
Enrollment ADT
 Registry ADT for UW - stores which students
are taking which courses
 Example operations:
int TakingCourse(int UWID, int SLN)
 tells if the student is taking the course specified by
SLN
void PrintSchedule(int UWID)
 print a list of all the courses this student is taking
void PrintCourseList(int SLN)
 print a list of all the students in this course
Linear ADTs
CSE 326 Autumn 2001
17
Array-of-Lists Application:
Adjacency List for Graphs
1
3
2
5
4
G
1
2
3
4
5
Linear ADTs
5
2
4
3
1
4
5
3
5
•Array G of unordered linked
lists
•Each list entry corresponds to
an edge in the graph
CSE 326 Autumn 2001
18
Reachability by Marking
 Suppose we want to mark all the nodes in the graph
which are reachable from a given node k.
 Let G[1..n] be the adjacency list rep. of the graph
 Let M[1..n] be the mark array, initially all falses.
void mark(int i) {
M[i] = true;
x = G[i]
while (x != NULL) {
if (M[x->node] == false)
mark(G[x->node])
x = x->next
}
}
Linear ADTs
CSE 326 Autumn 2001
19
Reach
1
3
2
M
4
5
G
1
5
2
2
4
3
3
1
4
4
5
3
5
5
Linear ADTs
CSE 326 Autumn 2001
20
Thoughts on Reachability
 The marking algorithm visits each node and each
edge at most once. Why?
 This marking algorithm uses Depth First Search. DFS
uses a stack to track nodes. Where?
 Graph reachability is closely related to garbage
collection




Linear ADTs
the nodes are blocks of memory
marking starts at all global and active local variables
the marked blocks are reachable from a variable
unmarked blocks are garbage
CSE 326 Autumn 2001
21
Linked Lists of Linked Lists:
Multivariate Polynomials
15 + 20y + xy10 + xy5 + 3x12 + 4x12y10 =
(15 + 20y)x0 + (y5 + y10)x1 + (3 + 4y10)x12
x0
x1
x12
0
1
12
y0
0
15
y5
5
1
y1
1
20
y10
10
1
exponent
coefficient
?
Linear ADTs
CSE 326 Autumn 2001
22
To do
 Try some list/stack/queue problems in Weiss
chapter 3 (not on HW1, but will be on Quiz 1)
 Start reading Weiss chapter 4 on Trees
Linear ADTs
CSE 326 Autumn 2001
23