Problem of the Day

1. Problem of the Day • Solve this equation by moving the numbers: 76 = 24

2. Problem of the Day • Solve this equation by moving the numbers: 76 = 24 72=49

3. CSC 212 – Data Structures Lecture 345:Implementing Traversals

4. 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?

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

6. 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

7. 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

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

9. Traversal Algorithms • So, how do we do each one of these? implement each traversal? • Recursion usually answer to questions involving trees • The algorithm uses same approach for all three • Where Nodes done only difference; rest is identical

10. 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

11. 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

12. 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

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

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

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

16. 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);

17. Better Solution public class EulerTour<E, R> {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;}

18. 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> v){r.out = r.left + " " + v.element() +}

19. 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> v){r.out = r.left + " " + v.element() +...}

20. 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 … I have no joke (post-order traversal) }void visitBelow(TourResult<String> r,Position<E> p){r.out = r.left + " " + p.element() +...}

21. Better Solution class InOrder<E> extends EulerTour<E,String>{// execute from before is here, but not enough space… void visitLeft(TourResult<String> r,Position<E> p) { // Do nothing – its too early }void visitBelow(TourResult<String> r,Position<E> p) { // Do nothing – its too early }

22. Better Solution class InOrder<E> extends EulerTour<E,String>{void visitRight(TourResult<String> r,Position<E> v){r.out = ""; if (getTree().hasLeft(v)) {r.out = r.left + " "; }r.out += p.element(); if (getTree().hasRight(v)) {r.out += " " + r.right; }}

23. 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?

24. Wait A Minute…

25. 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

26. Your Turn • Get into your groups and complete activity

27. For Next Lecture • Read parts of GT 7.1 & 7.3 for Monday • 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 posted & due next Tuesday (after break) • Programming Assignment #3 available today