Thought for the Day “To become truly great, one has to stand with people, not above them.” – Charles de Montesquieu

Traversing Trees We often need to work through a tree “visiting” each node Several different ways that we can do this: in-order pre-order post-order breadth-order etc., etc.

Traversal Methods In-Order (LNR): Pre-Order (NLR): Post-Order (LRN): d b e a f c g Pre-Order (NLR): a b d e c f g Post-Order (LRN): d e b f g c a Breadth-Order: a b c d e f g a b c d e f g

Writing Traversal Methods We can use the existing methods in our Tree class Recursion is the easiest way! Challenge (for those who don’t believe me!): write a non-recursive traversal method.

Printing the Contents of a Tree public void LNRPrint (Tree<Character> root) // Recursive in-order traversal of tree // printing out the nodes' data { if (root != null) { LNRPrint(root.left()); System.out.println(root.getData()); LNRPrint(root.right()); } } // LNRPrint Recursive calls

Iterators Tree traversals are common operations Useful to provide methods in tree classes But, we may want to do different things print add to total compare with a “search” value etc.

Solution: Provide methods that supply iterators objects have methods to move through the data structure, and access the data values See how it’s done later...

Ordered Binary Trees Binary Search Trees Trees so far: No requirement for ordering nodes Binary Search Tree Values less than the node’s value: in left subtree Otherwise in right subtree

Example LNR (in-order) traversal visits nodes in ascending order b t a k LNR (in-order) traversal visits nodes in ascending order a b k m m t

Implementation To prevent clients destroying the ordering we need a different design: remove addLeft and addRight methods hide the structure (inner “node” class) Class diagram: BinarySearchTree root insert, remove, contains, getLNRIterator, getNLRIterator, getLRNIterator

The BinarySearchTree Class public class BinarySearchTree <T extends Comparable> { private class BSTreeNode { public T data; public BSTreeNode lt, // Left subtree rt, // Right subtree parent; // Parent node } // inner class BSTreeNode private BSTreeNode root; ... Three pointers

Bounded Generic Type Parameters public class X<T extends Comparable> ... T can be any type that extends (implements) the Comparable interface Restricts the type of objects that can be used Here, Comparable is required for the ordering of the nodes

The Comparable Interface Standard Java interface Specifies the class must provide a method called compareTo: public int compareTo (Object o); /* Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. */

The Comparable Interface Many classes implement this interface wrapper classes, String, Date, etc. Allows us to insert items into the correct position in a binary search tree Is (comparable) object x < object y? if (x.compareTo(y) < 0)...

The insert method public void insert (T newValue) // Add a new node to the tree { if (root == null) root = new BSTreeNode(newValue); else insert(newValue, root); } // insert Overloaded, private method

The Private insert Method private void insert (T value, BSTreeNode root) { assert root != null; if (root.data.compareTo(value) > 0) // Add to left subtree if (root.lt != null) insert(value, root.lt); else root.lt = new BSTreeNode(value, root); else // Add to right subtree if (root.rt != null) insert(value, root.rt); root.rt = new BSTreeNode(value, root); } // insert Recursive calls