6 Stack ADTs

1. 6Stack ADTs • Stack concepts. • Stack applications. • A stack ADT: requirements, contract. • Implementations of stacks: using arrays, linked lists. • Stacks in the Java class library. © 2001, D.A. Watt and D.F. Brown

2. Stack concepts (1) • A stack is a last-in-first-out sequence of elements. Elements can added and removed only at one end (the top of the stack). • The depth of stack is the number of elements it contains. • An empty stack has depth zero.

3. 2001 Misérables Misérables Initially: After remov-ing a book: After adding “Misérables”: After adding “2001”: Rob Roy War & Peace War & Peace War & Peace War & Peace Moby Dick Moby Dick Moby Dick Moby Dick Stack concepts (2) • Illustration (stack of books):

4. Stack applications • Interpreter (e.g., the Java Virtual Machine) • maintains a stack containing intermediate results during evaluation of complicated expressions • also containing arguments and return addresses for method calls and returns. • Parser (e.g., a component of the Java compiler) • maintains a stack containing symbols encountered during parsing.

5. Example 1: text-file reversal • A text file is a sequence of (zero or more) lines. • To reverse the order of these lines, we must store them in a first-in-last-out sequence. • Text-file reversal algorithm: To output the lines of file in reverse order: 1. Make line-stack empty.2. For each line read from file, repeat: 2.1. Add line to the top of line-stack.3. While line-stack is not empty, repeat: 3.1. Remove a line from the top of line-stack into line. 3.2. Output line.4. Terminate.

6. Example 2: bracketing (1) • A phrase is well-bracketed if: • for every left bracket, there is a later matching right bracket • for every right bracket, there is an earlier matching left bracket • the subphrase between a pair of matching brackets is itself well-bracketed. • Examples (mathematical expressions): s (s – a)  (s – b)  (s – c) (– b + [b2 – 4ac]) / 2a s (s – a)  (s – b (s – c) s (s – a) s – b)  (s – c) (– b + [b2 – 4ac)] / 2a well-bracketed well-bracketed ill-bracketed ill-bracketed ill-bracketed

7. Example 2 (2) • Bracket matching algorithm: To test whether phrase is well-bracketed: 1. Make bracket-stack empty.2. For each symbol sym in phrase (scanning from left to right), repeat: 2.1. If sym is a left bracket: 2.1.1. Add sym to the top of bracket-stack. 2.2. If sym is a right bracket: 2.2.1. If bracket-stack is empty, terminate with false. 2.2.2. Remove a bracket from the top of bracket-stack into left. 2.2.3. If left and sym are not matched brackets, terminate with false. 3. Terminate with true if bracket-stack is empty, or false otherwise.

8. Stack ADT: requirements • Requirements: • It must be possible to make a stack empty. • It must be possible to add (‘push’) an element to the top of a stack. • It must be possible to remove (‘pop’) the topmost element from a stack. • It must be possible to test whether a stack is empty. • It should be possible to access the topmost element in a stack without removing it.

9. Stack ADT: contract (1) • Possible contract, expressed as a Java interface: publicinterface Stack { // Each Stack object is a stack whose elements are objects. /////////////// Accessors /////////////// publicboolean isEmpty (); // Return true if and only if this stack is empty. public Object getLast (); // Return the element at the top of this stack.

10. Stack ADT: contract (2) • Possible contract (continued): /////////////// Transformers /////////////// publicvoid clear (); // Make this stack empty. publicvoid addLast (Object elem); // Add elem as the top element of this stack. public Object removeLast (); // Remove and return the element at the top of this stack. }

11. topmost element unoccupied 0 1 depth–1 depth maxdepth–1 element element element Invariant: 1 maxdepth–1 length=0 Empty stack: 1 4 0 depth=3 5 2 Illustration(maxdepth = 6): Moby Dick War & Peace Rob Roy Implementation of stacks using arrays (1) • Represent a bounded stack (depth maxdepth) by: • variable depth, containing the current depth • array elems of length maxdepth, containing the stacked elements in elems[0… depth–1].

12. Implementation using arrays (2) • Java implementation: publicclass ArrayStack implements Stack { private Object[] elems;privateint depth; /////////////// Constructor /////////////// public ArrayStack (int maxDepth) { elems = new Object[maxDepth]; depth = 0; }

13. Implementation using arrays (3) • Java implementation (continued): /////////////// Accessors /////////////// publicboolean isEmpty () {return (depth == 0); } public Object getLast () {if (depth == 0) throw…;return elems[depth-1]; }

14. Implementation using arrays (4) • Java implementation (continued): /////////////// Transformers /////////////// publicvoid clear () {for (int i = 0; i < depth; i++) elems[i] = null; depth = 0; } publicvoid addLast (Object elem) {if (depth == elems.length) throw…; elems[depth++] = elem; }

15. Implementation using arrays (5) • Java implementation (continued): public Object removeLast () {if (depth == 0) throw…; Object topElem = elems[--depth]; elems[depth] = null;return topElem; } } • Analysis: • Operations isEmpty, getLast, addLast, removeLast have time complexity O(1). • Operation clear has time complexity O(n).

16. element element element Invariant: Empty stack: RobRoy War & Peace Moby Dick Illustration: Implementation of stacks using SLLs (1) • Represent an (unbounded) stack by an SLL, such that the first node contains the topmost element. topmost element

17. Implementation using SLLs (2) • Java implementation: publicclass LinkedStack implements Stack { private SLLNode top; /////////////// Constructor /////////////// public LinkedStack () { top = null; }

18. Implementation using SLLs (3) • Java implementation (continued): /////////////// Accessors /////////////// publicboolean isEmpty () {return (top == null); } public Object getLast () {if (top == null) throw…;return top.element; }

19. Implementation using SLLs (4) • Java implementation (continued): /////////////// Transformers /////////////// publicvoid clear () { top = null; } publicvoid addLast (Object elem) { top = new SLLNode(elem, top); }

20. Implementation using SLLs (5) • Java implementation (continued): public Object removeLast () {if (top == null) throw…; Object topElem = top.element; top = top.succ;return topElem; } } • Analysis: • All operations have time complexity O(1).

21. Stacks in the Java class library • Java provides no Stack interface or class as such. • However, the java.util.LinkedList class provides all the above Stack operations. • Illustration: import java.util.LinkedList; LinkedList bookStack = new LinkedList();bookStack.addLast("Moby Dick");bookStack.addLast("War & Peace");bookStack.addLast("Rob Roy");System.out.println(bookStack.removeLast());

22. Example 3: text-file reversal revisited (1) • Recall the text-file reversal algorithm of Example 1. • Implementation: publicstaticvoid reverse ( BufferedReader input, BufferedWriter output)throws IOException { LinkedList lineStack = new LinkedList();for (;;) { String line = input.readLine();if (line == null) break; // end of inputlineStack.addLast(line); } input.close();

23. Example 3 (2) • Implementation (continued): while (! lineStack.isEmpty()) { String line = lineStack.removeLast(); output.write(line + "\n"); } output.close();}