CSE 326 More Lists, Stacks and Queues

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

2. 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 CSE 326 Autumn 2001 2

3. 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() } Enqueue Dequeue c b a c b a c b a CSE 326 Autumn 2001 3

4. 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 } Circular Array Queue Q size - 1 0 b c d e f front back bool is_empty() { return (front == back) } bool is_full() { return front == (back + 1) % size } Note robustness checks!!! CSE 326 Autumn 2001 4

5. enqueue R enqueue O dequeue enqueue T enqueue A enqueue T dequeue dequeue enqueue E dequeue Circular Queue Example CSE 326 Autumn 2001 5

6. Linked List Q Data Structure b c d e f front back 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 } void enqueue(Object x) { if (is_empty()) front = back = new Node(x) else back->next = new Node(x) back = back->next } CSE 326 Autumn 2001 6

7. 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? CSE 326 Autumn 2001 7

8. 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 Listener Request Q Worker Responder Response Q responses CSE 326 Autumn 2001 8

9. E D C B A A F B C D E F 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. Push Pop class Stack { void push(object o) object pop() object top() bool is_empty() bool is_full() } CSE 326 Autumn 2001 9

10. void push(Object x) { assert(!is_full()) S[back] = x back++ } Object top() { assert(!is_empty()) return S[back - 1] } Array Stack Data Structure S size - 1 0 f e d c b back Object pop() { back-- return S[back] } bool is_empty() { return back == 0 } bool is_full() { return back == size } CSE 326 Autumn 2001 10

11. b c d e f back Linked List Stack Data Structure 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 } void push(Object x) { temp = back back = new Node(x) back->next = temp } Object top() { assert(!is_empty()) return back->data } CSE 326 Autumn 2001 11

12. 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 popreturn address pushreturn value return (jump to return address) Caller pop return value pop register contents resume Stack Application:Function Calls f1f2 stack frame f1 registers f1 return addr f1f2 params f2f3 stack frame f2 registers f2 return addr f2f3 params CSE 326 Autumn 2001 12

13. 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 CSE 326 Autumn 2001 13

14. Applications ofMultiple-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) CSE 326 Autumn 2001 14

15. Implementations ofMultiple-List Data Structures • Array of linked lists • Linked list of linked lists • Cross-List CSE 326 Autumn 2001 15

16. 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 CSE 326 Autumn 2001 16

17. 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 CSE 326 Autumn 2001 17

18. Array-of-Lists Application:Adjacency List for Graphs 1 3 2 5 4 G • Array G of unordered linked lists • Each list entry corresponds to an edge in the graph 1 5 2 2 4 3 5 3 1 4 4 5 3 5 CSE 326 Autumn 2001 18

19. 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 } } CSE 326 Autumn 2001 19

20. Reach 1 3 2 4 5 G M 1 5 2 2 4 3 5 3 1 4 4 5 3 5 CSE 326 Autumn 2001 20

21. 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 CSE 326 Autumn 2001 21

22. 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 exponent 0 12 1 coefficient y0 0 15 y5 5 1 y1 1 20 y10 10 1 ? CSE 326 Autumn 2001 22

23. 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 CSE 326 Autumn 2001 23