Podcast Ch 17 b Title Iterative Tree Traversal

Podcast Ch 17 b • Title: Iterative Tree Traversal • Description: Iterative tree traversal; the Inorder. Iterator Class; program 17. 2 • Participants: Barry Kurtz (instructor); John Helfert and Tobie Williams (students) • Textbook: Data Structures for Java; William H. Ford and William R. Topp

Iterative Tree Traversal • Traversing the nodes in a binary tree is more difficult than traversing a Linked. List or Array. List collection since a tree is a nonlinear structure and there is no one traversal order (e. g. preorder, inorder, postorder). – The problem with the recursive algorithms is that there is no escape from the recursive process until it completes. We need to simulate a recursive traversal with an iterative algorithm.

Iterative Tree Traversal (continued) • Our binary tree iterator implements the Iterator interface by using a stack to hold the nodes which have been visited. – The scan halt at any time, the programmer can deal with a node, and then continue the scan.

Iterative Tree Traversal (cont) • The figure gives a UML diagram for the class Inorder. Iterator that includes the instance variables and the private method go. Far. Left() which is critical to finding the "next" node.

Iterative Tree Traversal (continued) • Inorder Iterator Algorithm – Find the leftmost node in the tree by starting at the root and following the chain of left children until locating a node with an empty left subtree. During this process, the root and all intermediate nodes on the chain of left children are pushed on the stack.

Iterative Tree Traversal (continued) • Inorder Iterator Algorithm (continued) 1. Capture the value in the node. 2. If the right branch of the node is not empty, move to the right child and then traverse the chain of left children until locating a node with a null left subtree. This is the next node. During the traversal, push on the stack a reference to each node on the path.

Iterative Tree Traversal (continued) • Inorder Iterator Algorithm (concluded) 3. If the right branch of the node is empty, the scan of the node's left branch is complete, and the node itself has been visited. The next node to visit is on the stack. If the stack is not empty, pop it to determine the next node in the scan. If the stack is empty, all nodes have been visited and the scan concludes.

Iterative Tree Traversal (continued)

Student Question • Step by step show the stack for the inorder iterative traversal of the following tree

Practice Problem • Step by step show the stack for the inorder iterative traversal of the following tree

Implementing the Inorder. Iterator • The Inorder. Iterator class provides instances that execute an iterative inorder scan of a binary tree. – An Inorder. Iterator object scans a binary tree and access the value of the elements. The remove() method throws an Unsupported. Operation. Exception. – The instance variables include a stack for TNode references and the variable curr which references the next node. The end of a traversal occurs when curr becomes null.

Implementing the Inorder. Iterator (cont) • The class uses the private method go. Far. Left() to locate the first element and to execute rule 2. The method begins at node t and stacks all of the nodes until it locates one with a null left subtree. A reference to this node is the return value. public class Inorder. Iterator<T> implements Iterator<T> { private ALStack<TNode<T>> s = null; private TNode<T> curr = null; . . . private TNode<T> go. Far. Left(TNode<T> t) {. . . } }

Implementing the Inorder. Iterator Class (continued) // go far left from t, pushing all the nodes with // left children on stack s private TNode<T> go. Far. Left(TNode<T> t) { if (t == null) return null; while (t. left != null) { s. push(t); t = t. left; } return t; }

Implementing the Inorder. Iterator Class (continued) • The constructor allocates the stack and calls go. Far. Left() to position curr at the first node inorder. Since Inorder. Iterator is not included in a collection class, a user must pass the root of the binary tree as an argument. public Inorder. Iterator(TNode<T> root) { s = new ALStack<TNode<T>>(); curr = go. Far. Left(root); }

Implementing the Inorder. Iterator Class (continued) • The method next() implements Steps 1 through 3. In keeping with the requirements of the Iterator interface, next() throws No. Such. Element. Exception if the tree traversal is complete.

The Inorder. Iterator (concluded) public T next() { if (curr == null) throw new No. Such. Element. Exception( "Inorder. Scan: no elements remaining"); // capture the value in the node T return. Value = curr. node. Value; if (curr. right != null) // have a right subtree // stack nodes on left subtree curr = go. Far. Left(curr. right); else if (!s. is. Empty()) // no right subtree; there are other nodes // to visit; pop the stack curr = (TNode<T>)s. pop(); else // end of tree; set curr to null curr = null; return. Value; }

Student Question • Can you think of some practical applications for the inorder iterator?

Program 17. 2 • The static method, build. Time 24 Tree() in the Binary. Tree class builds the following binary tree of Time 24 objects.

Program 17. 2 (continued) • The program calls build. Time 24 Tree() to create the tree and then uses an inorder tree iterator to traverses the nodes. After each call to next(), the program updates the time value of the node by adding 60 minutes ( 1 hour). A call to display. Tree() outputs the updated tree.

Program 17. 2 (Run) Original tree 3: 15 18: 35 20: 55 10: 45 12: 00 5: 15 7: 30 15: 30 9: 15 Modified tree 4: 15 19: 35 21: 55 11: 45 13: 00 6: 15 8: 30 16: 30 10: 15

Program 17. 2 (continued) import ds. util. TNode; ds. util. Binary. Tree; ds. util. Inorder. Iterator; ds. time. Time 24; public class Program 17_2 { public static void main(String[] args) { // roots for the tree TNode<Time 24> root; // build a tree of Time 24 data root = Binary. Tree. build. Time 24 Tree(); // display the tree System. out. println("Original tree"); System. out. println(Binary. Tree. display. Tree( root, 5) + "n");

Program 17. 2 (concluded) // declare an inorder tree iterator Inorder. Iterator<Time 24> iter = new Inorder. Iterator<Time 24>(root); // go through the tree and add 1 hour while (iter. has. Next()){ // obtain the value in a tree node Time 24 t = iter. next(); // add 1 hour to the time t. add. Time(60); } System. out. println("Modified tree"); System. out. println (Binary. Tree. display. Tree(root, 5)); // delete the nodes in the tree Binary. Tree. clear. Tree(root); } }

Student Question • How could you write an preorder traversal of a binary tree that does not use recursion?

Practice Coding • Now that you have heard the discuss by John and Tobie, write a method that will print a preorder traversal without using recursion