Stacks and Queues CMPSC 122

Transcription

1 Stacks and Queues CMPSC 122 Stacks and queues are two fundamental abstract data types that will come up quite a bit in computer science. They're quite similar, so we'll look at them together here. I. Fundamentals of Stacks and Operations Here are some key facts about stacks: They organize data in a linear way (think in the same vein as arrays and linked lists) A stack has a defined top. A stack could be empty. When we add data to a stack, we say we push data onto the stack. When we remove data from a stack, we say we pop the stack. Data may only be added to the top of a stack. Likewise, data may only be removed from the top of a stack. For this reason (and as we'll illustrate via example), we say that stacks have last-in-first-out access. This is commonly abbreviated LIFO. We may only look at the top element of a stack and we may only remove one element at a time. It's helpful to maintain a stack's logical size. Sometimes, we call this the depth of the stack, because of how we access the elements. Thus, some operations that would generally be done on a stack are these: create a stack push pop look at the top element without removing it check if the stack is empty get the depth Two analogies: Think about a stack of trays in a cafeteria. You have to take the top tray. When someone cleans trays, the trays generally get put back on the top of the stack. Think about Pringles. You have to take the top chip out of the can, or off the top of the stack of Pringles. I doubt they had CS in mind, but the "Once you pop, you can't stop" slogan is pretty fitting here. (This analogy doesn't work so well for putting things on the stack, well, at least if you're being polite.) Page 1 of 7! Prepared by D. Hogan for PSU CMPSC 122

2 II. Stack Example We'll look at example stack of integers now: 1. Start with an empty stack. 2. Push 121 on the stack. 3. Push 122 on the stack. 4. Push 221 on the stack. 5. Push 360 on the stack. 6. Pop the stack. 7. Push 465 on the stack. 8. Pop the stack. 9. Pop the stack. III. Queue Fundamentals and Operations Here are some key facts about queus: Like stacks, they organize data in a linear way. A queue has a defined front and back. A queue could be empty. When we add data to a queue, we say that we enqueue that data. We enqueue at the back. When we remove data from a queue, the operation is to dequeue. We dequeue from the front. Since we enqueue at the back and dequeue from the front, the first item that is added to a queue must be the first that is removed. Thus, we say the kind of access queues have is first-in-first-out or FIFO. We may only look at the element at the front of a queue and we may only remove one element at a time. Again, maintaining the logical size is helpful. Sometimes, it's called the length, although this is a less significant term than depth is with stacks Page 2 of 7! Prepared by D. Hogan for PSU CMPSC 122

3 Thus, some operations that would generally be done on a queue are these: create a queue dequeue enqueue look at the front element without removing it check if the queue is empty get the logical size The very natural analogy for queues is waiting in a line, say at a checkout or going through security in an airport. The first person who got in line is the first person to be served. In fact, sometimes, such lines are called queues, although this in more common in British English than here. (Likewise, the expression "queue up" might be used to mean "form a line.") IV. Queue Example We'll look at a very similar example queue of integers now: 1. Start with an empty queue. 2. Enqueue Enqueue Enqueue Enqueue Dequeue. 7. Enqueue Dequeue. 9. Dequeue. Page 3 of 7! Prepared by D. Hogan for PSU CMPSC 122

4 V. Implementation of Stacks and Queues Stacks and queues are an abstract concept, and not something typically built-in in a language. They're something we can implement using the tools we know. Behind the scenes, we'd use either an array or linked list. Let's look at the four cases for implementation -- focusing on what data we would need: Stack implemented via an array: Stack implemented via a linked list: Queue implemented via a linked list: Queue implemented via an array: Question: What are the advantages and disadvantages of arrays and linked lists for stacks and queues? No matter which implementation you choose, the concepts are the same and the use of stacks and queues should be the same. The particulars of the implementation are insignificant, and the idea of abstraction comes back once again! Page 4 of 7! Prepared by D. Hogan for PSU CMPSC 122

5 VI. Stack Application: Parenthesization One particularly useful application of stacks is checking the balancing of parentheses, brackets, and braces. Consider the following expression: {1 + 2 * [x + y - 3 / (4 - y) + (y + 5) / (2 * x) ] / (5 * z ^ 2)} / 15 Evaluating such an expression might get tricky, and even making sure it's syntactically valid might take some effort. We could use a stack to do the checking: Whenever we encounter an opening parenthesis (or bracket or brace), we push it on the stack. When we encounter a closing parenthesis (or bracket or brace), we pop the stack -- and also check if what was on top was the right kind of symbol. If the stack is empty when we're done walking through the expression, the expression is good. Let's illustrate this for the example above. Question: What would it mean if the stack were not empty when we reached the end of the expression? Question: What would it mean if we try to pop an empty stack in traversing an expression? By the way, this idea could be used behind the scenes in compilers and it it's the idea behind the scenes in some IDEs that tell you your braces for methods and loops aren't right. Page 5 of 7! Prepared by D. Hogan for PSU CMPSC 122

6 VII. Stack Application: Call Stacks Another very important application of stacks in computer science is something called a call stack. When code is executed and a method call is encountered, something called an activation record is created for the function call and it's placed on the call stack. If, during the execution of that method call, another method call is encountered, another record goes on the call stack. This process goes on and on for all calls. When the end of a method is reached, the call stack is popped -- and control flow goes back to the calling method. The calling method will necessarily be on the top of the stack, so computers know exactly where to go upon returning from a method. Note also, that these activation records provide a nice insight into the matter of the scope of variables. Example: Here's a small block of pseduocode: MAIN FOO(a) GOO(a, b) HOO(a) { { { { x = 5 return a + 2 if a < b return a 2 y =FOO(x) } c = HOO(a) } z = GOO(x, y) else output z c = HOO(b) } return c * 10 } Illustrate the control flow of this code via a call stack. In some cases, the call stack doesn't get too exciting, but in others, it gets quite deep. In some languages like Java, you'll can see a trace of the call stack when something goes wrong (something called an exception). We'll also come back to the idea of call stacks when we learn about recursive functions later in this course. You'll learn more about the mechanics of activation records in CMPEN 331 as well. Page 6 of 7! Prepared by D. Hogan for PSU CMPSC 122

7 VIII. Analysis of Stack and Queue Operations As always, we should consider the running time of the key operations on stacks and queues. This section raises an interesting point I'll note before we go into the details: The implementation of an abstract data type affects the running time of its operations. So, running time ought to be a consideration in your implementation decisions. Knowing how abstract data types work and how to apply them is one thing and abstraction is great, but part of what distinguishes you as computer scientists (well, soon) is that you know how to implement them. (I'll take this opportunity to point out anecdotally that I've gotten reports from former students that they've impressed interviewers by knowing these things.) Let's take some time now to note the complications of and find the worst-case running times of these algorithms (where n is always the input size): Pushing onto a stack Popping from a stack Enqueing onto a queue Dequeuing from a queue IX. Closing Note Stacks and queues are interesting in their own right, but they come up again and again in implementing more advanced algorithms. Just remember to associate LIFO with stacks and FIFO with queues. Some of the algorithms that will come up in CMPSC 465 use stacks and queues, and you'll be expected to have the concept mastered coming into that course. Another related abstract data type is something called a priority queue. It is, of course, like a queue, but each element in the queue has a priority value associated with it. The order in which items are removed from a priority queue is not based on when they were enqueued like in an ordinary queue. The item of highest priority is removed every time we ask to access an item. I'll leave the discussion of priority queues to 465 (Section 6.5 in the standard CLRS Introduction to Algorithms text). Page 7 of 7! Prepared by D. Hogan for PSU CMPSC 122