5. Stacks and Queues

Connection to LList Can be implemented as a specialized linked-list Stacks are LIFO (Last-in-first-out) Adding is called pushing – only happens at end Removing is called popping – also happens at end Queues are FIFO (First-in-first-out) Adding happens at the start Removing happens only at the end.

Implementation Strategy #1 Inheritance (“Is-A” relationship) Use extends to inherit from LinkedList Add a redundant push and pop method. - (in Java) can’t hide inherited methods (like insert) + not much work needed. This is the approach taken by: java.util.Queue java.util.Stack public class Stack<E> extends LinkedList<E> { public Stack() { super(); } public void push(E val) { add(val); } public E pop() { remove(size() – 1); } }

Implementation Strategy #2 Composition (“Has-A” relationship) Make a new Stack class, add a protected Llist member. + (in Java) we can hide the methods we don’t want to expose - (in Java) more work: we must write wrappers for everything we do want to expose public class Stack<E> { protected LinkedList<E> mList; public Stack() { mList = new LinkedList<E>(); } public void push(E val) { mList.add(val); } public E pop() { mList.remove(size() – 1); } // … every other method we wish to expose }

Our Lab One of the first steps in a compiler / interpreter is a syntax check. One important syntax check is brace-matching. Take a language like Lisp (this is a @*&-ized version, btw): (exec (= i 0) (= n (input "max: ")) (while (i < n) (exec (if (and (== 0 (% i 3)) (== 0 (% i 5))) (print "FizzBuzz") (if (== 0 (% i 3)) (print "Fizz") (if (== 0 (% i 5)) (print "Buzz") (print i) ) (= i (+ i 1)) ))

Our Lab, cont. Do all the parentheses match? If not, where does the mis-match happen (line & col#)? Note: if we color-code the parens… They have to match from inside-out (exec (= i 0) (= n (input "max: ")) (while (i < n) (exec (if (and (== 0 (% i 3)) (== 0 (% i 5))) (print "FizzBuzz") (if (== 0 (% i 3)) (print "Fizz") (if (== 0 (% i 5)) (print "Buzz") (print i) ) (= i (+ i 1)) ))

Our Lab, cont. This is elegantly solved by a stack …of “Tokens”, where a Token is The character The line it appeared on The position within the line it appeared on Read the file character-by-character If it’s an opening brace: “(“, “{“ or “[“ Create a new token and push it on the stack If it’s a closing brace: “)”, “}” or “]” Look at the top of the stack (peek). If this char matches the one on top (e.g. “{“ matches “}”): pop the top off the stack. If not, we have a syntax error. If we reach the end of the file, but the stack is non-empty, we have one or more syntax.