Stacks and Queues CLRS, Section 10.1.

Slides:



Advertisements
Similar presentations
Building Java Programs Chapter 14
Advertisements

Stacks, Queues, and Deques. 2 A stack is a last in, first out (LIFO) data structure Items are removed from a stack in the reverse order from the way they.
CS 206 Introduction to Computer Science II 03 / 04 / 2009 Instructor: Michael Eckmann.
CS Data Structures II Review COSC 2006 April 14, 2017
1 Lecture 24 Abstract Data Types (ADT) –I Overview  What is an Abstract Data type?  What is Stack ADT?  Stack ADT Specifications  Array Implementation.
CS 206 Introduction to Computer Science II 10 / 26 / 2009 Instructor: Michael Eckmann.
TCSS 342, Winter 2005 Lecture Notes
CSE 143 Lecture 7 Stacks and Queues reading: Stuart Reges notes on website slides created by Marty Stepp
Building Java Programs
Building Java Programs
CSE 373 Data Structures and Algorithms Lecture 2: Queues.
CSE 143 Lecture 7 Stacks and Queues reading: "Appendix Q" (see course website) slides created by Marty Stepp and Hélène Martin
Week7 Stack Data Structures & Algorithms. Introduction to Stacks and Queues Widely used data structures Ordered List of element Easy to implement Easy.
CHAPTER 05 Compiled by: Dr. Mohammad Omar Alhawarat Stacks & Queues.
CSE 143 Lecture 5 Stacks and Queues slides created by Marty Stepp
Data Structures. The Stack: Definition A stack is an ordered collection of items into which new items may be inserted and from which items may be deleted.
CSE 143 Lecture 9 Interfaces; Stacks and Queues slides created by Marty Stepp
1 Chapter 7 Stacks and Queues. 2 Stack ADT Recall that ADT is abstract data type, a set of data and a set of operations that act upon the data. In a stack,
CSE 373: Data Structures and Algorithms Lecture 1: Introduction; ADTs; Stacks; Eclipse.
1 Chapter 20 Lists, Stacks, Queues Lecture 7 Dr. Musab Zghoul برمجة هيكلية.
Stacks and Queues. 2 3 Runtime Efficiency efficiency: measure of computing resources used by code. can be relative to speed (time), memory (space), etc.
CSE 373: Data Structures and Algorithms Lecture 2: Queues.
Stacks & Queues. Introduction to Stacks and Queues Widely used data structures Ordered List of element Easy to implement Easy to use.
CSE 373 Data Structures and Algorithms Lecture 1: Introduction; ADTs; Stacks; Eclipse.
M180: Data Structures & Algorithms in Java Stacks Arab Open University 1.
Click to edit Master text styles Stacks Data Structure.
Stacks and Queues. 2 Abstract Data Types (ADTs) abstract data type (ADT): A specification of a collection of data and the operations that can be performed.
Stacks (and Queues).
Stacks Access is allowed only at one point of the structure, normally termed the top of the stack access to the most recently added item only Operations.
Building Java Programs
CSE 373 Implementing a Stack/Queue as a Linked List
QueueStack CS1020.
Stacks and Queues.
Stacks.
CSE 373: Data Structures and Algorithms
Stacks and Queues.
CSE 373: Data Structures and Algorithms
Stacks and Queues.
Building Java Programs Chapter 14
Building Java Programs
Stacks and Queues.
Building Java Programs
i206: Lecture 11: Stacks, Queues
CMSC 341 Lecture 5 Stacks, Queues
Principles of Computing – UFCFA3-30-1
i206: Lecture 10: Lists, Stacks, Queues
Stacks and queues.
Building Java Programs Chapter 14
Stacks Data Structures and Problem Solving with C++: Walls and Mirrors, Carrano and Henry, © 2013.
Stacks and Queues.
slides created by Marty Stepp
Building Java Programs
Building Java Programs
Building Java Programs Chapter 14
slides created by Alyssa Harding
Stack A data structure in which elements are inserted and removed only at one end (called the top). Enforces Last-In-First-Out (LIFO) Uses of Stacks Evaluating.
Data Structures and Algorithms for Information Processing
Cs212: Data Structures Computer Science Department Lecture 6: Stacks.
slides created by Marty Stepp
Stacks.
Based on slides by Alyssa Harding & Marty Stepp
Topic 15 Implementing and Using Stacks
More Data Structures (Part 1)
Lecture 2: Stacks and Queues
slides created by Alyssa Harding
Generics, Stack, Queue Based on slides by Alyssa Harding
slides created by Marty Stepp
Stacks, Queues, and Deques
CSE 373 Java Collection Framework reading: Weiss Ch. 3, 4.8
Stacks and Queues.
Presentation transcript:

Stacks and Queues CLRS, Section 10.1

Abstract Data Types (ADTs) Abstract Data Type (ADT): A specification of a collection of data and the operations that can be performed on it. Describes what a collection does, not how it does it Consumers of a stack or queue do not need to know how they are implemented. We just need to understand the idea of the collection and what operations it can perform. Stacks usually implemented with arrays. Queues often implemented with a linked list, but can use a circular array. CS 321 - Data Structures

Stacks and Queues queue stack Some data structures are constrained so consumers only use optimized operations. stack: retrieves elements in reverse order as added. queue: retrieves elements in same order as added. push pop, peek top 3 2 bottom 1 front back 1 2 3 dequeue, first enqueue queue stack CS 321 - Data Structures

Stacks Stack: A collection based on the principle of adding elements and retrieving them in the opposite order. Last-In, First-Out ("LIFO") Elements are stored in order of insertion. We do not think of them as having indexes. Consumer can only add/remove/examine the last element added (the "top"). basic stack operations: push: Add an element to the top. pop: Remove the top element. peek: Examine the top element. push pop, peek analogy: trays of food at the sizzler top 3 2 bottom 1 CS 321 - Data Structures stack

Stacks in Computer Science Programming languages and compilers: Method calls are placed onto a stack. call=push return=pop Compilers use stacks to evaluate expressions. Matching up related pairs of things: Find out whether a string is a palindrome. Examine a file to see if its braces { } match. Convert "infix" expressions to pre/postfix. Sophisticated algorithms: Searching through a maze with "backtracking." Many programs use an "undo stack" of previous operations. CS 321 - Data Structures

Stacks and Queues Operations Last-in, first-out (LIFO) Queue First-in, first-out (FIFO) Operations: push (insert) pop (delete) Implementation: Array S of size n. Attribute S.top pointing to the index of the most recently inserted element. Operations: enqueue (insert) dequeue (delete) CS 321 - Data Structures

Stack Example Empty stack S S: S.top 1 2 3 4 5 CS 321 - Data Structures

Stack Example Empty stack S push(4) S: S.top 1 2 3 4 5 CS 321 - Data Structures

Stack Example Empty stack S push(4) push(1) S: S.top 1 2 3 4 5 CS 321 - Data Structures

Stack Example Empty stack S push(4) push(1) push(3) S: S.top 1 2 3 4 5 CS 321 - Data Structures

Stack Example Empty stack S push(4) push(1) push(3) pop() S: S.top 1 2 5 S: CS 321 - Data Structures

Stack Example Empty stack S push(4) push(1) push(3) pop() push(8) S: S.top 1 2 3 4 5 8 S: CS 321 - Data Structures

Stack Example Empty stack S push(4) push(1) push(3) pop() push(8) S: S.top 1 2 3 4 5 S: CS 321 - Data Structures

Stack Implementation When S.top = 0, the stack is empty. If we do pop on an empty stack, we have an underflow exception. If S.top > n, we have an overflow exception. CS 321 - Data Structures

Each of the three operations takes O(1) time. Stack Implementation Each of the three operations takes O(1) time. CS 321 - Data Structures

Stack Limitations You cannot loop over a stack in the usual way. Assume we created our own Stack class. Stack<Integer> s = new Stack<Integer>(); ... for (int i = 0; i < s.size(); i++) { do something with s.get(i); } Instead, pop each element until the stack is empty. // process (and destroy) an entire stack while (!s.isEmpty()) { do something with s.pop(); CS 321 - Data Structures

What Happened to My Stack? Suppose we're asked to write a method max that accepts a Stack of Integers and returns the largest Integer in the stack: // Precondition: !s.isEmpty() public static void max(Stack<Integer> s) { int maxValue = s.pop(); while (!s.isEmpty()) { int next = s.pop(); maxValue = Math.max(maxValue, next); } return maxValue; The algorithm is correct, but what is wrong with the code? CS 321 - Data Structures

What Happened to My Stack? The code destroys the stack in figuring out its answer. To fix this, you must save and restore the stack's contents: public static void max(Stack<Integer> s) { Stack<Integer> backup = new Stack<Integer>(); int maxValue = s.pop(); backup.push(maxValue); while (!s.isEmpty()) { int next = s.pop(); backup.push(next); maxValue = Math.max(maxValue, next); } while (!backup.isEmpty()) { // restore s.push(backup.pop()); return maxValue;

Queues queue Queue: Retrieves elements in the order they were added. First-In, First-Out ("FIFO") Elements are stored in order of insertion but don't have indexes. Client can only add to the end of the queue, and can only examine/remove the front of the queue. Basic queue operations: enqueue (add): Add an element to the back. dequeue (remove): Remove the front element. first: Examine the front element. front back 1 2 3 dequeue, first enqueue analogy: trays of food at the sizzler queue CS 321 - Data Structures

Queues in Computer Science Operating systems: Queue of print jobs to send to the printer. Queue of programs / processes to be run. Queue of network data packets to send. Programming: Modeling a line of customers or clients. Storing a queue of computations to be performed in order. Real world examples: People on an escalator or waiting in a line. Cars at a gas station (or on an assembly line). CS 321 - Data Structures

Last-in, first-out (LIFO) First-in, first-out (FIFO) Stacks and Queues Stack Last-in, first-out (LIFO) Queue First-in, first-out (FIFO) Operations: PUSH (insert) POP (delete) Implementation: Array S of size n Attribute S.top pointing to the index of the most recently inserted element Operations: ENQUEUE (insert) DEQUEUE (delete) Implementation: Array Q of size n Attributes Q.head and Q.tail CS 321 - Data Structures

Queue Implementation The array Q is considered as a circular array. Q.head points to the index in which the earliest inserted element resides. Q.tail points to the index in which a new element should be inserted. Initially, we have Q.head = Q.tail = 1. CS 321 - Data Structures

Queue Example CS 321 - Data Structures

Queue Example After: ENQUEUE(17) ENQUEUE(3) ENQUEUE(5) CS 321 - Data Structures

Queue Example After: DEQUEUE() X CS 321 - Data Structures

Each operation takes O(1) time. Queue Implementation Each operation takes O(1) time. CS 321 - Data Structures

Using Queues As with stacks, must pull contents out of queue to view them. Assume we created our own Queue class. // process (and destroy) an entire queue while (!q.isEmpty()) { do something with q.dequeue(); } To examine each element exactly once. int size = q.size(); for (int i = 0; i < size; i++) { (including possibly re-adding it to the queue) Why do we need the size variable? CS 321 - Data Structures

Mixing Stacks and Queues We often mix Stacks and Queues to achieve certain effects. Example: Reverse the order of the elements of a queue. Queue<Integer> q = new Queue<Integer>(); q.enqueue(1); q.enqueue(2); q.enqueue(3); // [1, 2, 3] Stack<Integer> s = new Stack<Integer>(); while (!q.isEmpty()) { // Q -> S s.push(q.dequeue()); } while (!s.isEmpty()) { // S -> Q q.enqueue (s.pop()); System.out.println(q); // [3, 2, 1]

Java Stack Class Stack<String> s = new Stack<String>(); s.push("a"); s.push("b"); s.push("c"); // bottom ["a", "b", "c"] top System.out.println(s.pop()); // "c" Stack has other methods that are off-limits (not efficient) Stack<T>() constructs a new stack with elements of type T push(value) places given value on top of stack pop() removes top value from stack and returns it; throws EmptyStackException if stack is empty peek() returns top value from stack without removing it; size() returns number of elements in stack isEmpty() returns true if stack has no elements CS 321 - Data Structures

Java Queue Interface Queue<Integer> q = new LinkedList<Integer>(); q.add(42); q.add(-3); q.add(17); // front [42, -3, 17] back System.out.println(q.remove()); // 42 IMPORTANT: When constructing a queue, you must use a new LinkedList object instead of a new Queue object. Because Queue is an interface. add(value) places given value at back of queue remove() removes value from front of queue and returns it; throws a NoSuchElementException if queue is empty peek() returns front value from queue without removing it; returns null if queue is empty size() returns number of elements in queue isEmpty() returns true if queue has no elements CS 321 - Data Structures

Exercises Write a method stutter that accepts a queue of Integers as a parameter and replaces every element of the queue with two copies of that element. [1, 2, 3] becomes [1, 1, 2, 2, 3, 3] Write a method mirror that accepts a queue of Strings as a parameter and appends the queue's contents to itself in reverse order. [a, b, c] becomes [a, b, c, c, b, a] CS 321 - Data Structures

CS 321 - Data Structures