Lecture 35: Implementing Traversals

1. CSC 212 – Data Structures Lecture 35:Implementing Traversals

2. Traversing Binary Trees • Trees are another Collection of data • Positions required in the Tree ADT methods • ADT uses generic type to specify type of element • Want to iterate through tree’s elements • This is not optional; Trees are Iterable • Could use any traversal algorithm; choose logical one • But how do we implement traversals & Iterator?

3. Traversal Methods • Many traversals, differ in order nodes visited • Do parent then do each kid in pre-order traversal

4. Traversal Methods • Many traversals, differ in order nodes visited • Do parent then do each kid in pre-order traversal • Post-order traversal does kids before doing parents

5. Traversal Methods • Many traversals, differ in order nodes visited • Do parent then do each kid in pre-order traversal • Post-order traversal does kids before doing parents • Do left kid, parent, then right kid in in-order traversal

6. Traversal Algorithms • So, how do we do each one of these?

7. Binary Tree Traversal Algorithmtraverse(tree, v) // Do node here for pre-order traversal traverse(tree, tree.left(v)); // Do node here for in-order traversal traverse(tree, tree.right(v)); // Do node here for post-order traversal

8. Important Feature of Any Coder • Nearly all of the great coders are inherently lazy • Hope for you all -- you have this part completed • Unfortunately, true laziness requires lot of work • Debugging code wastes time could be websurfing • To make small change, more time lost rewriting code • Small amount of planning save lots of time later

9. Template Method Pattern • Common design pattern used to simplify code • Implement class of algorithms using an abstract class • Class leaves all actual work in abstract methods • Subclasses written for each member algorithm • To make concrete, each overrides abstract method • Method performs specific actions for that algorithm • New algorithms are very quick & easy to write • Most bugs already found & fixed, so less work here • Leaves only actions & actions usually are small

10. Binary Tree Traversal Template public class EulerTour<E, R> {abstract void visit(Position<E> p);public Rtour(BinaryTree<E> t, Position<E> p) {TourResult<R> r = new TourResult<R>(); if (t.hasLeft(p)) {r.left = tour(t, t.left(p)); }visit(p); if (t.hasRight(p)) {r.right = tour(t, t.right(p)); } return r.out;}

11. Oops… public class EulerTour<E, R> {abstract void visit(Position<E> p);public Rtour(BinaryTree<E> t, Position<E> p) {TourResult<R> r = new TourResult<R>(); if (t.hasLeft(p)) {r.left = tour(t, t.left(p)); }visit(p); if (t.hasRight(p)) {r.right = tour(t, t.right(p)); } return r.out;} Pre-order traversal needsvisithere

12. More Oops… public class EulerTour<E, R> {abstract void visit(Position<E> p);public Rtour(BinaryTree<E> t, Position<E> p) {TourResult<R> r = new TourResult<R>(); if (t.hasLeft(p)) {r.left = tour(t, t.left(p)); }visit(p); if (t.hasRight(p)) {r.right = tour(t, t.right(p)); } return r.out;} Post-order traversal needsvisithere

13. Better Solution public class Traversal<E, R> {// Perform actions before kids processedabstract void visitLeft(Position<E> p);// Perform actions after kids processedabstract void visitRight(Position<E> p);// Perform actions between when kids processedabstract void visitBelow(Position<E> p);

14. Better Solution public class EulerTour<E, R> {public Rtour(BinaryTree<E> t, Position<E> p) {TourResult<R> r = new TourResult<R>();visitLeft(p); if (t.hasLeft(p)) {r.left = tour(t, t.left(p)); }visitBelow(p); if (t.hasRight(p)) {r.right = tour(t, t.right(p)); }visitRight(p); return r.out;}

15. Better Solution class InOrder<E> extends EulerTour<E,String>{public String execute(BinaryTree<E> t) { init(t); return eulerTour(t.root());}void visitLeft(TourResult<String> r,Position<E> p){// Do nothing – we are not Woody Allen (pre-order traversal) }void visitRight(TourResult<String> r,Position<E> p){// Do nothing – we are not Michael Jackson (post-order traversal) }void visitBelow(TourResult<String> r,Position<E> p){r.out = r.left + " " + p.element() +}

16. Wait A Minute… • Lecture began talking about Tree's Iterator • Implementing traversals discussed for rest of lecture • I may not know much, but traversals != Iterator • How to implement next() & hasNext() • Recursion can't be used, since calls occur over time • How can we reuse these ideas to make an iterator? • Was this a ruse; is lecture completely worthless?

17. Cheating To Win • next() & hasNext() very hard to implement • Much easier for Sequences (which are Iterable) • In fact, we have already done this for Sequence • Use that Iteratorby adding elements to Sequence • Define new subclass for this type of traversal • Valid to build entire Iterator all at one go • Add & combine Sequences in visit* methods • executemethod returns a Sequence

18. For Next Lecture • Read parts of GT 7.1 & 7.3 for Wednesday • How do we implement a tree? • Binary trees are similar; how do we implement them? • I loved CSC111; can’t we use arrays for binary trees? • Week #12 assignment posted & due tomorrow • Programming Assignment #3 available today