Date post: | 30-Dec-2015 |
Category: |
Documents |
Upload: | sonia-mosley |
View: | 28 times |
Download: | 0 times |
LECTURE 35:IMPLEMENTING TRAVERSALS
CSC 212 – Data Structures
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?
Traversal Methods
Many traversals, differ in order nodes visited Do parent then do each kid in pre-order
traversal
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
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
Traversal Algorithms
So, how do we do each one of these?
Binary Tree Traversal
Algorithm traverse(tree, v)// Do node here for pre-order traversaltraverse(tree, tree.left(v));// Do node here for in-order traversaltraverse(tree, tree.right(v));// Do node here for post-order traversal
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
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
Binary Tree Traversal Templatepublic class EulerTour<E, R> {
abstract void visit(Position<E> p);public R tour(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;}
Oops…
public class EulerTour<E, R> {abstract void visit(Position<E> p);public R tour(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 needs visit here
More Oops…
public class EulerTour<E, R> {abstract void visit(Position<E> p);public R tour(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 needs visit here
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);
Better Solution
public class EulerTour<E, R> {public R tour(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;}
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() + }
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?
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 Iterator by 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 execute method returns a Sequence
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