1. COSC2007 Data Structures II Chapter 11 Trees II

2. 2 Topics ADT Binary Tree (BT) Operations Tree traversal BT Implementation Array-based LL-based Expression Notation and Tree traversal

3. 3 ADT Binary Tree

4. 4 BT Traversal Suppose I wanted to ‘visit’ all the nodes in this tree. Furthermore, suppose I wanted to perform some operation on the data there (such as printing it out). A B DE H IJK C FG L root What are some of the possible visitation patterns we could use?

5. 5 BT Traversal Visit every node in a BT exactly once. Each visit performs the same operations on each node Natural traversal orders: Pre-order Node-Left-Right (NLR) In-order Left-Node-Right (LNR) Post-order Left-Right-Node (LRN)

6. 6 Pre-order Traversal Each node is processed the first time it is observed. i.e. before any node in either subtree. A Possible Pattern Visit Root Node Visit Left subtree in preorder Visit Right subtree Must be applied at all levels of the tree. A B DE H IJK C FG L root 4 3 5 2 7 6 8 1 10 9 11 12 Called an PreOrder Traversal

7. 7 Pre-order Traversal Pseudocode preorder (binaryTree:BinaryTree ) // Traverses the binary tree binaryTree in preorder. // Assumes that “visit a node” means to display the node’s data item if (binaryTree is not empty ) { Display the data in the root of binaryTree preorder ( Left subtree of binaryTree ’s root ) preorder ( Right subtree of binaryTree ’s root ) }

8. 8 In-order Traversal Each node is processed the second time it is observed. i.e. after all the nodes in its left subtree but before any of the nodes in its right subtree. A Possible Pattern Visit Left subtree Visit Root node Visit Right subtree Must be applied at all levels of the tree. A B DE H IJK C FG L root 1 2 3 4 5 6 7 8 9 10 11 12

9. 9 In-order Traversal Pseudocode inorder (binaryTree:BinaryTree ) // Traverses the binary tree binaryTree in inorder. // Assumes that “visit a node” means to display the node’s data item if (binaryTree is not empty ) { inorder ( Left subtree of binaryTree ’s root ) Display the data in the root of binaryTree inorder ( Right subtree of binaryTree ’s root ) }

10. 10 Post-order Traversal Each node is processed the third time it is observed. i.e. after all nodes in both of its subtrees. A Possible Pattern Visit Left subtree Visit Right subtree Visit Root Node Must be applied at all levels of the tree. A B DE H IJK C FG L root 1 3 2 7 4 6 5 8 11 10 9 12 H I D J K E B F L G C A

11. 11 Post-order Traversal Pseudocode postorder (binaryTree:BinaryTree ) // Traverses the binary tree binaryTree in postorder. // Assumes that “visit a node” means to display the node’s data item if (binaryTree is not empty ) { postorder ( Left subtree of binaryTree ’s root ) postorder ( Right subtree of binaryTree ’s root ) Display the data in the root of binaryTree }

12. 12 Implementation of BT Possible Implementations: Array based Fast access Difficult to change Used if elements are not modified often Reference (Pointer) based Slower Easy to modify More flexible when elements are modified often

13. 13 BT Array-Based Implementation Nodes: A Java Node class Each node should contain: Data portion Left-child index Right-child index Tree: Array of structures For empty tree index? James Tony Bob NeilDavisAdam

14. 14 BT Array-Based Implementation public class TreeNode // node in the tree { private Object item ;// data item in the tree private int leftChild; // index to left child private int rightChild; // index to right child ……. //constructor } // end of TreeNode public abstract class BinaryTreeArrayedBased { protected final int MAX_NODES =100; protected TreeNode tree []; protected int root; // index of root protected int free; // index of next unused array location ……..//constructor and methods } // end BinaryTreeArrayedBased

15. 15 BT Array-Based Implementation Array based is only good for complete tree Since tree is complete, it maps nicely onto an array representation. 0 1 2 3 4 5 6 7 8 9 10 11 12 A B C D E F G H I J K L T: last A B DE H IJK C FG L

16. 16 BT Array-Based Implementation For Complete Trees: A formula can be used to find the location of any node in the tree Lchild ( Tree [ i ] ) = Tree [ 2 * i + 1 ] Rchild ( Tree [ i ] ) = Tree [ 2 * i + 2 ] Parent (Tree [ i ] ) = Tree [ ( i - 1) / 2 ] 01234560123456 Neil David Adams Tony Bob James Tony Bob NeilDavisAdam

17. 17 Reference-Based Implementation Typical for implementing BTs Only the pointer to the root of the tree can be accessed by BT class clients The data structure would be private data member of a class of binary trees

18. 18 Reference -Based Implementation public class TreeNode // node in the tree { private Object item; // data portion private TreeNode leftChildPtr; // pointer to left child private TreeNode rightChildPtr; // pointer to right child TreeNode() {}; TreeNode(Object nodeItem, TreeNode left, TreeNode right ) { } ……. } // end TreeNode class

19. 19 Reference -Based Implementation public abstract class BinaryTreeBasis { protected TreeNode root; ……. // constructor and methods } // end BinaryTreeBasis class If the tree is empty, then root is ? The root of a nonempty BT has a left subtree and right subtree, each is BT root.getRight () root.getLeft()

20. 20 Reference -Based Implementation Example: Item LChildPtr RChildPtr Root Root of left child subtree Root of right child subtree

21. 21 The TreeNode Class public class TreeNode { private Object item; private TreeNode leftChild; private TreeNode rightChild; public TreeNode() {} //Constructors public TreeNode(Object myElement) { item = myElement; leftChild = null; rightChild = null; } public TreeNode(Object newItem, TreeNode left, TreeNode right){ item = newItem; leftChild = left; rightChild = right; }

22. 22 TreeNode, cont'd. public Object getItem() { return item;} public void setItem(Object newItem) {item = newItem;} public void setLeft(TreeNode left) { leftChild = left;} public TreeNode getLeft() { return leftChild;} public void setRight(TreeNode right) { rightChild = right;} public TreeNode getRight() { return rightChild;} }

23. 23 TreeException public class TreeException extends RuntimeException { public TreeException(String s) { super (s); } } // end TreeException

24. 24 The BinaryTreeBasis class public abstract class BinaryTreeBasis { protected TreeNode root; public BinaryTreeBasis () { root = null; } //end constructor public BinaryTreeBasis (object rootItem) { root = new TreeNode (rootItem, null, null); } //end constructor public boolean isEmpty() { //true is tree is empty return root == null; } public void makeEmpty() { //sets root of tree to null root =null; }

25. 25 The BinaryTreeBasis class public Object getRootItem() throws TreeException { if (root == null) throw new TreeException (“ Empty tree”); else return root.getItem(); } //end getRootItem() public TreeNode getRoot() { return root; } //end getRoot() } //end class BinaryTreeBasis t: 1

26. 26 The BinaryTree Class public class BinaryTree extends BinaryTreeBasis { //the Constructors public BinaryTree() {} public BinaryTree(Object rootItem) { super (rootItem); } //end constructor public BinaryTree(Object rootItem, BinaryTree leftTree, BinaryTree rightTree) { root = new TreeNode(rootItem, null, null); attachLeftSubTree (leftTree); attachRightSubTree (rightTree); } // end constructor all the methods go here } //end BinaryTree t: 1

27. 27 The BinaryTree Class public void setRootItem(Object newItem) { if (root == null) root = new TreeNode (newItem, null, null); else root.setItem(newItem); } //end setRootItem tree: 2 45

28. 28 The BinaryTree Class public void attachLeft(Object newItem) { if (!isEmpty() && root.getLeft() == null) root.setLeft(new TreeNode(newItem, null, null)); } // end attachLeft public void attachRight(Object newItem) { if (!isEmpty() && root.getRight() == null) root.setRight(new TreeNode(newItem, null, null)); } // end attachRight t 1 23 t: 1

29. 29 The BinaryTree Class public void attachLeftSubtree(BinaryTree leftTree) throws TreeException { if (isEmpty()) throw new TreeException("Cannot attach left subtree to empty tree."); else if (root.getLeft() != null) throw new TreeException("Cannot overwrite left subtree."); else { //no empty tree, no left child root.setLeft(leftTree.root); leftTree.makeEmpty(); } //end attachLeftSubtree } t: 1 3 6 78 2 45 2 45 tree1: 3 6 78

30. 30 The BinaryTree Class public void attachRightSubtree(BinaryTree rightTree) throws TreeException { if (isEmpty()) throw new TreeException("Cannot attach left subtree to empty tree."); else if (root.getRight() != null) throw new TreeException("Cannot overwrite right subtree."); else { //no empty tree, no right child root.setRight(rightTree.root); rightTree.makeEmpty(); } //end attachRightSubtree }

31. 31 The BinaryTree Class protected BinaryTree (TreeNode rootNode) { root = rootNode } //end constructor public BinaryTree detachLeftSubtree() throws TreeException { if (isEmpty()) throw new TreeException("Cannot detach empty tree."); else { // create a tree points to the leftsubtree BinaryTree leftTree; leftTree = new BinaryTree (root.getLeft()); root.setLeft (null); return leftTree; } } //end detachLeftSubtree }

32. 32 The BinaryTree Class public BinaryTree detachRightSubtree() throws TreeException { if (isEmpty()) throw new TreeException("Cannot detach empty tree."); else { // create a tree points to the rightsubtree BinaryTree rightTree; rightTree = new BinaryTree (root.getRight()); root.setRight (null); return rightTree; } } //end detachRightSubtree }

33. 33 preOrderPrint( ) public void preOrderPrint(TreeNode rootNode) throws TreeException { if (rootNode!=null) { System.out.print(rootNode.getItem() + " "); preOrderPrint(rootNode.getLeft()); preOrderPrint(rootNode.getRight()); } Print tree using preorder traversal: 1 2 4 5 3 6 7 8 t: 1 3 6 78 2 45

34. 34 inOrderPrint() Print tree using inorder traversal: 4 2 5 1 7 6 8 3 t: 1 3 6 78 2 45 public void inOrderPrint(TreeNode rootNode) throws TreeException { if (rootNode!=null) { inOrderPrint(rootNode.getLeft()); System.out.print(rootNode.getItem() + " "); inOrderPrint(rootNode.getRight()); }

35. 35 postOrderPrint( ) Print tree using postOrder traversal: 4 5 2 7 8 6 3 1 t: 1 3 6 78 2 45 public void postOrderPrint(TreeNode rootNode) throws TreeException { if (rootNode!=null) { postOrderPrint(rootNode.getLeft()); postOrderPrint(rootNode.getRight()); System.out.print(rootNode.getItem() + " "); }

36. 36 An Example Program public class BinaryTreeTest { public static void main (String args[]) throws BinaryTreeException { BinaryTree t = new BinaryTree(new Integer(1)); System.out.println("Element at root of tree = " + t.getRootElement()); System.out.println("Initial tree is: "); t.preOrderPrint(t.getRoot()); System.out.println(); BinaryTree tree1 = new BinaryTree(new Integer(2)); tree1.attachLeft(new Integer(4)); tree1.attachRight(new Integer(5)); System.out.println("Tree1 is: "); tree1.preOrderPrint(tree1.getRoot()); System.out.println(); tree1: 2 45 t: 1

37. 37 Example, cont'd. BinaryTree tree2 = new BinaryTree(new Integer(6)); tree2.attachLeft(new Integer(7)); tree2.attachRight(new Integer(8)); System.out.println("tree2 is: "); tree2.preOrderPrint(tree2.getRoot()); System.out.println(); BinaryTree tree3 = new BinaryTree(new Integer(3)); tree3.attachLeftSubtree(tree2); System.out.println("Tree3 is: "); tree3.preOrderPrint(tree3.getRoot()); System.out.println(); t.attachLeftSubtree(tree1); t.attachRightSubtree(tree3); System.out.println("Final tree is: "); t.preOrderPrint(t.getRoot()); System.out.println(); } tree2: 6 78 tree3: 3 6 78 t: 1 3 6 78 2 45

38. 38 Expression Tree Given a math expression, there exists a unique corresponding expression tree. 5+ (6* (8-6)) + 5* 6- 86

39. 39 Preorder Of Expression Tree + a b - c d + e f * / Gives prefix form of expression! /*+ab-cd+ef

40. 40 Inorder Of Expression Tree + a b - c d + e f * / Gives infix form of expression (sans parentheses)! ea+b*cd/+f-

41. 41 Postorder Of Expression Tree + a b - c d + e f * / Gives postfix form of expression! ab+cd-*ef+/