- 84 Views
- Uploaded on
- Presentation posted in: General

Problem of the Day

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

- Solve this equation by moving the numbers:
76 = 24

- Solve this equation by moving the numbers:
76 = 24

72=49

CSC 212 â€“ Data Structures

Lecture 345:Implementing Traversals

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

- Many traversals, differ in order nodes visited
- Do parent then do each kid in pre-order traversal

- 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

- 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

- So, how do we do each one of these?

- 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

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

- 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

- 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

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;}

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

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

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

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;}

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() +}

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() +...}

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() +...}

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 }

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; }}

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

- 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

- Get into your groups and complete activity

- 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