1. CSE 326 More Lists, Stacks and Queues David Kaplan Dept of Computer Science & Engineering Autumn 2001

2. Linear ADTsCSE 326 Autumn 20012 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

3. Linear ADTsCSE 326 Autumn 20013 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() } EnqueueDequeue abc abcabc

4. Linear ADTsCSE 326 Autumn 20014 Circular Array Queue 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 } bcdef Q 0 size - 1 frontback bool is_empty() { return (front == back) } bool is_full() { return front == (back + 1) % size } Note robustness checks!!!

5. Linear ADTsCSE 326 Autumn 20015 Circular Queue Example enqueue R enqueue O dequeue enqueue T enqueue A enqueue T dequeue enqueue E dequeue

6. Linear ADTsCSE 326 Autumn 20016 Linked List Q Data Structure bcdef frontback void enqueue(Object x) { if (is_empty()) front = back = new Node(x) else back->next = new Node(x) back = back->next } 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 }

7. Linear ADTsCSE 326 Autumn 20017 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?

8. Linear ADTsCSE 326 Autumn 20018 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 The Web requests Listener Responder responses Request Q Response Q Worker

9. Linear ADTsCSE 326 Autumn 20019 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() } A BCDEFBCDEF E D C B A F PushPop

10. Linear ADTsCSE 326 Autumn 200110 Array Stack Data Structure S 0 size - 1 fedcb void push(Object x) { assert(!is_full()) S[back] = x back++ } Object top() { assert(!is_empty()) return S[back - 1] } back Object pop() { back-- return S[back] } bool is_empty() { return back == 0 } bool is_full() { return back == size }

11. Linear ADTsCSE 326 Autumn 200111 Linked List Stack Data Structure bcdef back void push(Object x) { temp = back back = new Node(x) back->next = temp } Object top() { assert(!is_empty()) return back->data } 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 }

12. Linear ADTsCSE 326 Autumn 200112 f2  f3 stack frame f1  f2 stack frame 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 Caller  push register contents  push return address  push call parameters Callee  pop call parameters  run local code  pop return address  push return value  return (jump to return address) Caller  pop return value  pop register contents  resume f1 registers f1 return addr f1  f2 params f2 registers f2 return addr f2  f3 params

13. Linear ADTsCSE 326 Autumn 200113 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

14. Linear ADTsCSE 326 Autumn 200114 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)

15. Linear ADTsCSE 326 Autumn 200115 Implementations of Multiple-List Data Structures  Array of linked lists  Linked list of linked lists  Cross-List

16. Linear ADTsCSE 326 Autumn 200116 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

17. Linear ADTsCSE 326 Autumn 200117 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

18. Linear ADTsCSE 326 Autumn 200118 Array-of-Lists Application: Adjacency List for Graphs 435 1 4 13 4 2 5 G 1 2 3 4 5 53 52 Array G of unordered linked lists Each list entry corresponds to an edge in the graph

19. Linear ADTsCSE 326 Autumn 200119 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 false s. 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 }

20. Linear ADTsCSE 326 Autumn 200120 13 4 2 5 435 1 4 G 1 2 3 4 5 53 52 M Reach

21. Linear ADTsCSE 326 Autumn 200121 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  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

22. Linear ADTsCSE 326 Autumn 200122 Linked Lists of Linked Lists: Multivariate Polynomials 15 + 20y + xy 10 + xy 5 + 3x 12 + 4x 12 y 10 = (15 + 20y)x 0 + (y 5 + y 10 )x 1 + (3 + 4y 10 )x 12 0 15 1 12 x0x0 x1x1 x 12 exponent coefficient 0 y0y0 201 y1y1 15 y5y5 110 y 10 ?

23. Linear ADTsCSE 326 Autumn 200123 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