Stacks Goodrich, Tamassia, Goldwasser Stacks

Size: px

Start display at page:

Download "Stacks Goodrich, Tamassia, Goldwasser Stacks"

Jewel Woods
5 years ago
Views:

1 Presentation for use with the textbook Data Structures and Algorithms in Java, 6 th edition, by M. T. Goodrich, R. Tamassia, and M. H. Goldwasser, Wiley, 2014 Stacks Stacks 1

the last inserted element Auxiliary stack operations: object top(): returns the last inserted element without removing it

2 The Stack ADT The Stack ADT stores arbitrary objects Insertions and deletions follow the last-in first-out scheme Think of a spring-loaded plate dispenser Main stack operations: push(object): inserts an element object pop(): removes and returns the last inserted element Auxiliary stack operations: object top(): returns the last inserted element without removing it integer size(): returns the number of elements stored boolean isempty(): indicates whether no elements are stored Stacks 2

3 Stack Interface in Java Java interface corresponding to our Stack ADT Assumes null is returned from top() and pop() when stack is empty Different from the built-in Java class java.util.stack public interface Stack<E> { int size(); boolean isempty(); E top(); void push(e element); E pop(); } Stacks 3

4 Example Stacks 4

5 Applications of Stacks Direct applications Page-visited history in a Web browser Undo sequence in a text editor Chain of method calls in the Java Virtual Machine Indirect applications Auxiliary data structure for algorithms Component of other data structures Stacks 5

6 Array-based Stack A simple way of implementing the Stack ADT uses an array We add elements from left to right A variable keeps track of the index of the top element Algorithm size() return t + 1 Algorithm pop() if isempty() then return null else t t 1 return S[t + 1] S t Stacks 6

7 Array-based Stack (cont.) The array storing the stack elements may become full A push operation will then throw a FullStackException Limitation of the arraybased implementation Not intrinsic to the Stack ADT Algorithm push(o) if t = S.length 1 then throw IllegalStateException else t t + 1 S[t] o S t Stacks 7

8 Performance and Limitations Performance Let n be the number of elements in the stack The space used is O(n) Each operation runs in time O(1) Limitations The maximum size of the stack must be defined a priori and cannot be changed Trying to push a new element into a full stack causes an implementation-specific exception Stacks 8

9 Array-based Stack in Java public class ArrayStack<E> implements Stack<E> { // holds the stack elements private E[ ] S; // index to top element private int top = -1; // constructor public ArrayStack(int capacity) { S = (E[ ]) new Object[capacity]); } public E pop() { if isempty() return null; E temp = S[top]; // facilitate garbage collection: S[top] = null; top = top 1; return temp; } (other methods of Stack interface) Stacks 9

10 Example Use in Java public class Tester { // other methods public intreverse(integer a[]) { Stack<Integer> s; s = new ArrayStack<Integer>(); } (code to reverse array a) public floatreverse(float f[]) { Stack<Float> s; s = new ArrayStack<Float>(); } (code to reverse array f) Stacks 10

11 Parentheses Matching Each (, {, or [ must be paired with a matching ), }, or [ correct: ( )(( )){([( )])} correct: ((( )(( )){([( )])} incorrect: )(( )){([( )])} incorrect: ({[ ])} incorrect: ( Stacks 11

12 Parenthesis Matching (Java) public static boolean ismatched(string expression) { final String opening = "({["; // opening delimiters final String closing = ")}]"; // respective closing delimiters Stack<Character> buffer = new LinkedStack<>( ); for (char c : expression.tochararray( )) { if (opening.indexof(c)!= 1) // this is a left delimiter buffer.push(c); else if (closing.indexof(c)!= 1) { // this is a right delimiter if (buffer.isempty( )) // nothing to match with return false; if (closing.indexof(c)!= opening.indexof(buffer.pop( ))) return false; // mismatched delimiter } } return buffer.isempty( ); // were all opening delimiters matched? } Stacks 12

13 HTML Tag Matching For fully-correct HTML, each <name> should pair with a matching </name> <body> <center> <h1> The Little Boat </h1> </center> <p> The storm tossed the little boat like a cheap sneaker in an old washing machine. The three drunken fishermen were used to such treatment, of course, but not the tree salesman, who even as a stowaway now felt that he had overpaid for the voyage. </p> <ol> <li> Will the salesman die? </li> <li> What color is the boat? </li> <li> And what about Naomi? </li> </ol> </body> The Little Boat The storm tossed the little boat like a cheap sneaker in an old washing machine. The three drunken fishermen were used to such treatment, of course, but not the tree salesman, who even as a stowaway now felt that he had overpaid for the voyage. 1. Will the salesman die? 2. What color is the boat? 3. And what about Naomi? Stacks 13

14 HTML Tag Matching (Java) public static boolean ishtmlmatched(string html) { Stack<String> buffer = new LinkedStack<>( ); int j = html.indexof('<'); // find first < character (if any) while (j!= 1) { int k = html.indexof('>', j+1); // find next > character if (k == 1) return false; // invalid tag String tag = html.substring(j+1, k); // strip away < > if (!tag.startswith("/")) // this is an opening tag buffer.push(tag); else { // this is a closing tag if (buffer.isempty( )) return false; // no tag to match if (!tag.substring(1).equals(buffer.pop( ))) return false; // mismatched tag } j = html.indexof('<', k+1); // find next < character (if any) } return buffer.isempty( ); // were all opening tags matched? } Stacks 14

15 Evaluating Arithmetic Expressions Slide by Matt Stallmann included with permission * = (14 (3 * 2) ) + 7 Operator precedence * has precedence over +/ Associativity operators of the same precedence group evaluated from left to right Example: (x y) + z rather than x (y + z) Idea: push each operator on the stack, but first pop and perform higher and equal precedence operations. Stacks 15

16 Algorithm for Slide by Matt Stallmann included with permission. Evaluating Expressions Two stacks: opstk holds operators valstk holds values Use $ as special end of input token with lowest precedence Algorithm doop() x valstk.pop(); y valstk.pop(); op opstk.pop(); valstk.push( y op x ) Algorithm repeatops( refop ): while ( valstk.size() > 1 prec(refop) prec(opstk.top()) doop() Algorithm EvalExp() Input: a stream of tokens representing an arithmetic expression (with numbers) Output: the value of the expression while there s another token z if isnumber(z) then else repeatops($); valstk.push(z) repeatops(z); opstk.push(z) return valstk.top() Stacks 16

17 Algorithm on an Example Expression * Slide by Matt Stallmann included with permission. Operator has lower precedence than +/ * * * $ $ 5 14 $ F Stacks 17

18 Presentation for use with the textbook Data Structures and Algorithms in Java, 6 th edition, by M. T. Goodrich, R. Tamassia, and M. H. Goldwasser, Wiley, 2014 Queues Queues 18

19 The Queue ADT The Queue ADT stores arbitrary objects Insertions and deletions follow the first-in first-out scheme Insertions are at the rear of the queue and removals are at the front of the queue Main queue operations: enqueue(object): inserts an element at the end of the queue object dequeue(): removes and returns the element at the front of the queue Auxiliary queue operations: object first(): returns the element at the front without removing it integer size(): returns the number of elements stored boolean isempty(): indicates whether no elements are stored Boundary cases: Attempting the execution of dequeue or first on an empty queue returns null Queues 19

20 Example Operation Output Q enqueue(5) (5) enqueue(3) (5, 3) dequeue() 5 (3) enqueue(7) (3, 7) dequeue() 3 (7) first() 7 (7) dequeue() 7 () dequeue() null () isempty() true () enqueue(9) (9) enqueue(7) (9, 7) size() 2 (9, 7) enqueue(3) (9, 7, 3) enqueue(5) (9, 7, 3, 5) dequeue() 9 (7, 3, 5) Queues 20

21 Applications of Queues Direct applications Waiting lists, bureaucracy Access to shared resources (e.g., printer) Multiprogramming Indirect applications Auxiliary data structure for algorithms Component of other data structures Queues 21

22 Array-based Queue Use an array of size N in a circular fashion Two variables keep track of the front and size f index of the front element sz number of stored elements When the queue has fewer than N elements, array location r = (f + sz) mod N is the first empty slot past the rear of the queue normal configuration Q f r wrapped-around configuration Q r f Queues 22

23 Queue Operations We use the modulo operator (remainder of division) Algorithm size() return sz Algorithm isempty() return (sz == 0) Q Q f r r f Queues 23

24 Queue Operations (cont.) Operation enqueue throws an exception if the array is full This exception is implementationdependent Algorithm enqueue(o) if size() = N 1 then throw IllegalStateException else r (f + sz) mod N Q[r] o sz (sz + 1) Q Q f r r f Queues 24

25 Queue Operations (cont.) Note that operation dequeue returns null if the queue is empty Q Algorithm dequeue() if isempty() then return null else o Q[f] f (f + 1) mod N sz (sz 1) return o f r Q r f Queues 25

26 Queue Interface in Java Java interface corresponding to our Queue ADT Assumes that first() and dequeue() return null if queue is empty public interface Queue<E> { int size(); boolean isempty(); E first(); void enqueue(e e); E dequeue(); } Queues 26

27 Array-based Implementation Queues 27

28 Array-based Implementation (2) Queues 28

29 Comparison to java.util.queue Our Queue methods and corresponding methods of java.util.queue: Queues 29

30 Application: Round Robin Schedulers We can implement a round robin scheduler using a queue Q by repeatedly performing the following steps: 1. e = Q.dequeue() 2. Service element e 3. Q.enqueue(e) Queue Dequeue Enqueue Shared Service Queues 30

Stacks Goodrich, Tamassia Stacks

Stacks Goodrich, Tamassia Stacks Stacks Stacks 1 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations on the data Error conditions associated with operations