COMP 103 Tree Traversals Lindsay Groves 2016-T2 Lecture 22 Marcus Frean, Lindsay Groves, Peter Andreae, and Thomas Kuehne VUW Lindsay Groves School of Engineering and Computer Science, Victoria University of Wellington 2016-T2 Lecture 22

RECAP-TODAY RECAP Building and traversing general trees Recursive depth-first traversal TODAY Depth-First vs Breadth-First Traversal Iterative traversals using stacks and queues Bounded depth-first search and iterative deepening Best-first search Chapter 16.2

Depth-first Traversal, recursively e.g., list all employee names Use recursion (and iteration to step through the children) public void listAll() { System.out.println(this.name); // Visit the root for (OrgTreeNode child : this.children) child.listAll(); // Visit the children } Can also be done using recursion.

Managing Depth-First Traversal Need to remember what nodes are still being worked on, and which of their children have been processed already In a recursive depth-first traversal (eg. "ListAll" from earlier), activation stacks and loop control take care of the bookkeeping! When doesn’t this work? A B D E C H G M I K F L J A print own name process children... return B print own name process children... return D print own name process children... return …

Breadth-first Traversal What about printing the nodes by level? root first then second level, then third level, …. Or find the shallowest node with a given value. A B Julie Jenny D E F C Jenny Jude Jiles I…. A B D E C H G M I K F L J

Tracking State during Breadth-First Traversal What nodes do we have to remember? Which order do we work on them? A B D E C H G M I K F L J

Breadth-first Traversal: Use a Queue! public void BreadthFirstTraversal(TreeNode root) { Queue<TreeNode> todo = new LinkedList<TreeNode>(); todo.offer(root); // add while (!todo.isEmpty()) { TreeNode node = todo.poll(); // remove System.out.println(node.name()); for (TreeNode child : node.getChildren()) todo.offer(child); } Look Ma’, no recursion! A B D E C H G M I K F L J

Tracking State during Depth-First Traversal What nodes do we have to remember? Which order do we work on them? A B D E C H G M I K F L J

Depth-First Traversal: Use a Stack! public void DepthFirstTraversal(TreeNode root) { Stack <TreeNode> todo = new Stack<TreeNode>(); todo.push(root); // add while (!todo.isEmpty()) { TreeNode node = todo.pop(); // remove System.out.println(node.name()); for (TreeNode child : node.getChildren()) todo.push(child); } Which traversal order does this implement? Look Ma’, no recursion! A B D E C H G M I K F L J

Iterator for binary (search) trees Iterator keeps a stack of nodes on current path Stop when stack is empty To get next node: (outline!) If current node is a leaf, delete it Else push its children onto the stack (NOTE: This is just a brief note added as a hint because it’s in the assignment, not intended as a detailed explanation!)

In-order Traversal, iteratively? H B A C F I E G

Depth-First vs Breadth-First Visit one child and all of its descendants before its siblings May visit root before, after, or between its children + Requires only one branch to manage traversal! − May find “costly” results first, and may not find results at all (infinite search trees) Breadth-First (level-order): Visit nodes in order of increasing depth May choose nodes in a level in a specific order − Requires accumulation of levels to manage traversal + Finds minimal solutions and guarantees success!

Cost of tree traversals For an n-ary tree of height h: Depth-first traversal stores up to h nodes Just on branch from root to current node Breadth- first traversal stores up to nh nodes! All nodes on all levels to current node Impractical for large n. Can we do better?

Depth-first search public TreeNode<E> find(E item) { } Like depth-first traversal, except we stop on finding a node with the value we’re looking for Or more generally with a node satisfying a given search criterion – see discussion of comparators This version returns the node found, and null if not found public TreeNode<E> find(E item) { if (this.value == item ) return this; for (TreeNode<E> child : this.children) TreeNode<E> r = child.find(item); if ( r ) return r; return null; }

Bounded depth-first search Limit the depth to which a dfs will go Pass max depth as an extra argument decrease on each recursive call exit when it reaches zero public TreeNode<E> find(E item, int n) { if ( n == 0 ) return null; if (this.value == item ) return this; for (TreeNode<E> child : this.children) TreeNode<E> r = child.find(item, n-1); if ( r ) return r; return null; }

Iterative deepening for ( int d = 1; d++; d <= max ) } Use bounded dfs with bigger and bigger bound Guaranteed to find shortest path Still only needs to store h nodes for current path Number of nodes at next level is equal to number of nodes at all earlier levels, so cost of revisiting them is not significant! public TreeNode<E> find(E item) { for ( int d = 1; d++; d <= max ) TreeNode<E> r = child.find(item, d); if ( r ) return r; return null; }

Best-first search Suppose we want to find the cheapest path to a node with a given value, where we have costs associated with edges, and cost of a path is the sum of the edge costs. At each step, we want to explore the node with the least cost so far, rather than the newest/oldest as in dfs/bfs. How can we modify our search algorithm to achieve this? Can we use a suitable data structure to make this efficient?