Download presentation
Presentation is loading. Please wait.
Published byAusten Bishop Modified over 9 years ago
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
Similar presentations
© 2025 SlidePlayer.com. Inc.
All rights reserved.