1. © 2004 Goodrich, Tamassia Trees1 Chapter 7 Trees Make Money Fast! Stock Fraud Ponzi Scheme Bank Robbery

2. © 2004 Goodrich, Tamassia Trees2 7.1 General Trees Tree is one of the most important non-linear Data Structures in computing. Tree structures are important because they allow us to implement a host of algorithms much faster than when using linear data structures, such as list. Trees also provide a natural way to organize data in many areas such as: File systems Graphical User Interfaces (GUI) Databases Web Sites and many other computer systems.

3. © 2004 Goodrich, Tamassia Trees3 What is a Tree? Computers”R”Us SalesR&D Manufacturing LaptopsDesktops US International Europe Asia Canada Fig. 7.1. a tree representing the organization of a fictitious corporation

4. © 2004 Goodrich, Tamassia Trees4 Tree Structure In computer science, a tree is an abstract model of a hierarchical structure, with some objects being “ above ” and some “ below ” others. A tree consists of nodes with a parent-child relationship, rather than the simple “ before ” and “ after ” relationship, found between objects in sequential ( linear ) structures. A famous example of hierarchical structure ( tree ) is the family tree. Applications: Organization charts File systems Programming environments

5. © 2004 Goodrich, Tamassia Trees5 7.1.1 Tree Definitions and Properties A tree T, is an abstract data type that stores elements hierarchically. Except the top element ( root ), each element in a tree has a parent and zero or more children elements. root : node without parent (Node A) Internal node : node with at least one child (A, B, C, F) External node ( leaf ): node without children (E, I, J, K, G, H, D) Sibling nodes : Two nodes that are children of the same parent are Siblings. Depth of a node : number of its ancestors Height of a tree : maximum depth of any node Ancestors of a node : parent, grandparent, grand-grandparent, … etc. Descendants of a node : child, grandchild, grand- grandchild, … etc. Subtree : a tree consisting of a node and its descendants

6. © 2004 Goodrich, Tamassia Trees6 Example A B D C GH E F I J K subtree Fig.7.2 is an example of a tree T: T root is node A Internal (branch) nodes are nodes A, B, C, F External nodes ( leaves ) are nodes E, I, J, K, G, H, D Depth of node F is 2 Height of T is 3 Ancestors of node H are C and A Children of node A are B, C and D Nodes B, C and D are siblings Descendants of node B are E, F, I, J and K Fig. 7.2: Example of Tree

7. © 2004 Goodrich, Tamassia Trees7 Formal Definition of a Tree Formally, we define a tree T as a finite set of nodes storing elements such that the nodes have a parent-child relationship, that satisfies the following properties: If T is nonempty, it has a specially designated node, called the root of T, that has no parent. Each node v of T other than the root has a unique parent node w. Every node with parent w is a child of w. Note that a tree may be empty.

8. © 2004 Goodrich, Tamassia Trees8 Recursive Definition of a Tree: A tree T is either empty, or has a finite set of one or more nodes such that: i. There is one specially designated node, called the root, and ii. The remaining nodes, (excluding the root), are partitioned into m ≥ 0 disjoint sets T 1, T 2, …, T m, and each of these is in turn a tree. iii. The trees Ti (i = 1, 2, …, m) are called the sub- trees of the root.

9. © 2004 Goodrich, Tamassia Trees9 Subtree of Tree T The subtree of a tree T, rooted at node v is the tree consisting all the descendants of v in T (including v itself). Edges and Paths in Trees: An edge of tree T is a pair of nodes (u,v), such that u is the parent of v, or vice versa. A path of T is a sequence of nodes such any two consecutive nodes in the sequence form an edge. As an example of a path, (Figure 7.2), is the sequence A, B, F, K. where (A, B) or (B, A) is an edge.

10. © 2004 Goodrich, Tamassia Trees10 Ordered Trees A tree is ordered if there is a linear ordering defined for the children of each node; That’s, we can identify the children of a node as being the first, second, third, and so on. Such an ordering is usually shown by arranging siblings left to right, according to their ordering. Ordered trees typically indicate the linear order among siblings by listing them in the correct order. A famous example of ordered trees is the family tree.

11. © 2004 Goodrich, Tamassia Trees11 7.1.2 Tree ADT  The tree ADT stores elements at positions, which are defined relative to neighboring positions.  Positions in a tree are its nodes, and the neighboring positions satisfy the parent-child relationships that define a valid tree.  Tree nodes may store arbitrary objects.  As with a list position, a position object for a tree supports the method: element() : that returns the object stored at this position (or node).  The tree ADT supports four types of methods, as follows.

12. © 2004 Goodrich, Tamassia Trees12 Methods of a Tree ADT 1. Accessor Methods We use positions to abstract nodes. The real power of node positions in a tree comes from the accessor methods of the tree ADT that return and accept positions, such as the following: root(): Return the position of the tree’s root; an error occurs if the tree is empty. parent(p): Return the position of the parent of p; an error occurs if p is the root. children(p): Return an iterable collection containing the children of node p.

13. © 2004 Goodrich, Tamassia Trees13 Notice that:  If a tree T is ordered, then the iterable collection, children(p), stores the children of p in their linear order.  If p is an external node, then children(p) is empty.  Any method that takes a position as argument should generate an error condition if that position is invalid.

14. © 2004 Goodrich, Tamassia Trees14 2. Generic methods size(): Return the number of nodes in the tree. isEmpty(): Test whether the tree has any nodes or not. Iterator(): Return an iterator of all the elements stored at nodes of the tree. positions(): Return an iterable collection of all the nodes of the tree. Methods of a Tree ADT (Cont.)

15. © 2004 Goodrich, Tamassia Trees15 Methods of a Tree ADT (Cont.) 3. Query methods In addition to the above fundamental accessor methods, the tree ADT also supports the following Boolean query methods: isInternal(p): Test whether node p is an internal node isExternal(p): Test whether node p is an external node isRoot(p): Test whether node p is the root node These methods make programming with tree easier and more readable, since we can use them in the conditionals of if - statements and while -loops, rather than using a non-intuitive conditional.

16. © 2004 Goodrich, Tamassia Trees16 Methods of a Tree ADT (Cont.) 4. Update Method The tree ADT also supports the following update method: replace(p, e): Replace with e and return the element stored at node p. Additional update methods may be defined by data structures implementing the tree ADT

17. © 2004 Goodrich, Tamassia Trees17 Tree ADT Exceptions An interface for the tree ADT uses the following exceptions to indicate error conditions:  InvalidPositionException: This error condition may be thrown by any method taking a position as an argument to indicate that the position is invalid.  BoundaryViolationException: This error condition may be thrown by method parent() if it’s called on the root.  EmptyTreeException: This error condition may be thrown by method root() if it’s called on an empty tree.

18. © 2004 Goodrich, Tamassia Trees18 7.1.3 A Linked Structure for General Trees A natural way to implement a tree T is to use a linked structure, where we represent each node p of T by a position object with the following fields (see Figure): A reference to the element stored at p. A link to the parent of p. A some kind of collection (e.g., a list or array) to store links to the children of p.

19. © 2004 Goodrich, Tamassia Trees19  7.1.3 Linked Structure for General Trees A node is represented by an object storing Element Parent node Sequence of children nodes Node objects implement the Position ADT B D A CE F B  ADF  C  E

20. © 2004 Goodrich, Tamassia Trees20 Preorder Traversal A traversal visits the nodes of a tree in a systematic manner In a preorder traversal, a node is visited before its descendants Application: print a structured document, e.g. content list Make Money Fast! 1. MotivationsReferences2. Methods 2.1 Stock Fraud 2.2 Ponzi Scheme 1.1 Greed1.2 Avidity 2.3 Bank Robbery 1 2 3 5 4 678 9 Algorithm preOrder(v) visit(v) for each child w of v preOrder (w)

21. © 2004 Goodrich, Tamassia Trees21 Postorder Traversal In a postorder traversal, a node is visited after its descendants Application: compute space used by files in a directory and its subdirectories Algorithm postOrder(v) for each child w of v postOrder (w) visit(v) cs16/ homeworks/ todo.txt 1K programs/ DDR.java 10K Stocks.java 25K h1c.doc 3K h1nc.doc 2K Robot.java 20K 9 3 1 7 2 456 8

22. © 2004 Goodrich, Tamassia Trees22 Binary Trees (§ 6.3) A binary tree is a tree with the following properties: Each internal node has at most two children (exactly two for proper binary trees) The children of a node are an ordered pair We call the children of an internal node left child and right child Alternative recursive definition: a binary tree is either a tree consisting of a single node, or a tree whose root has an ordered pair of children, each of which is a binary tree Applications: arithmetic expressions decision processes searching A B C FG D E H I

23. © 2004 Goodrich, Tamassia Trees23 Arithmetic Expression Tree Binary tree associated with an arithmetic expression internal nodes: operators external nodes: operands Example: arithmetic expression tree for the expression (2  ( a  1)  (3  b))    2 a1 3b

24. © 2004 Goodrich, Tamassia Trees24 Decision Tree Binary tree associated with a decision process internal nodes: questions with yes/no answer external nodes: decisions Example: dining decision Want a fast meal? How about coffee?On expense account? StarbucksSpike’sAl FornoCafé Paragon Yes No YesNoYesNo

25. © 2004 Goodrich, Tamassia Trees25 Properties of Proper Binary Trees Notation n number of nodes e number of external nodes i number of internal nodes h height Properties: e  i  1 n  2e  1 h  i h  (n  1)  2 e  2 h h  log 2 e h  log 2 (n  1)  1

26. © 2004 Goodrich, Tamassia Trees26 BinaryTree ADT (§ 6.3.1) The BinaryTree ADT extends the Tree ADT, i.e., it inherits all the methods of the Tree ADT Additional methods: position left(p) position right(p) boolean hasLeft(p) boolean hasRight(p) Update methods may be defined by data structures implementing the BinaryTree ADT

27. © 2004 Goodrich, Tamassia Trees27 Inorder Traversal In an inorder traversal a node is visited after its left subtree and before its right subtree Application: draw a binary tree x(v) = inorder rank of v y(v) = depth of v Algorithm inOrder(v) if hasLeft (v) inOrder (left (v)) visit(v) if hasRight (v) inOrder (right (v)) 3 1 2 5 6 79 8 4

28. © 2004 Goodrich, Tamassia Trees28 Print Arithmetic Expressions Specialization of an inorder traversal print operand or operator when visiting node print “(“ before traversing left subtree print “)“ after traversing right subtree Algorithm printExpression(v) if hasLeft (v) print( “(’’ ) inOrder (left(v)) print(v.element ()) if hasRight (v) inOrder (right(v)) print ( “)’’ )    2 a1 3b ((2  ( a  1))  (3  b))

29. © 2004 Goodrich, Tamassia Trees29 Evaluate Arithmetic Expressions Specialization of a postorder traversal recursive method returning the value of a subtree when visiting an internal node, combine the values of the subtrees Algorithm evalExpr(v) if isExternal (v) return v.element () else x  evalExpr(leftChild (v)) y  evalExpr(rightChild (v))   operator stored at v return x  y    2 51 32

30. © 2004 Goodrich, Tamassia Trees30 Euler Tour Traversal Generic traversal of a binary tree Includes a special cases the preorder, postorder and inorder traversals Walk around the tree and visit each node three times: on the left (preorder) from below (inorder) on the right (postorder)    2 51 32 L B R 

31. © 2004 Goodrich, Tamassia Trees31 Template Method Pattern Generic algorithm that can be specialized by redefining certain steps Implemented by means of an abstract Java class Visit methods that can be redefined by subclasses Template method eulerTour Recursively called on the left and right children A Result object with fields leftResult, rightResult and finalResult keeps track of the output of the recursive calls to eulerTour public abstract class EulerTour { protected BinaryTree tree; protected void visitExternal(Position p, Result r) { } protected void visitLeft(Position p, Result r) { } protected void visitBelow(Position p, Result r) { } protected void visitRight(Position p, Result r) { } protected Object eulerTour(Position p) { Result r = new Result(); if tree.isExternal(p) { visitExternal(p, r); } else { visitLeft(p, r); r.leftResult = eulerTour(tree.left(p)); visitBelow(p, r); r.rightResult = eulerTour(tree.right(p)); visitRight(p, r); return r.finalResult; } …

32. © 2004 Goodrich, Tamassia Trees32 Specializations of EulerTour We show how to specialize class EulerTour to evaluate an arithmetic expression Assumptions External nodes store Integer objects Internal nodes store Operator objects supporting method operation (Integer, Integer) public class EvaluateExpression extends EulerTour { protected void visitExternal(Position p, Result r) { r.finalResult = (Integer) p.element(); } protected void visitRight(Position p, Result r) { Operator op = (Operator) p.element(); r.finalResult = op.operation( (Integer) r.leftResult, (Integer) r.rightResult ); } … }

33. © 2004 Goodrich, Tamassia Trees33 Linked Structure for Binary Trees A node is represented by an object storing Element Parent node Left child node Right child node Node objects implement the Position ADT B D A CE   BADCE 

34. © 2004 Goodrich, Tamassia Trees34 Array-Based Representation of Binary Trees nodes are stored in an array … let rank(node) be defined as follows: rank(root) = 1 if node is the left child of parent(node), rank(node) = 2*rank(parent(node)) if node is the right child of parent(node), rank(node) = 2*rank(parent(node))+1 1 23 6 7 45 1011 A HG FE D C B J