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