1 / 24

Chapter 7: Trees

Chapter 7: Trees. Objectives: Introduce general tree structure and Tree ADT Discuss the depth and height of trees Introduce the tree traversal algorithms Specialize to binary trees Implement binary trees with linked structure and array-list structure Introduce the Template Method Pattern.

hansons
Download Presentation

Chapter 7: Trees

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 7: Trees Objectives: Introduce general tree structure and Tree ADT Discuss the depth and height of trees Introduce the tree traversal algorithms Specialize to binary trees Implement binary trees with linked structure and array-list structure Introduce the Template Method Pattern CSC311: Data Structures

  2. Computers”R”Us Sales Manufacturing R&D US International Laptops Desktops Europe Asia Canada What is a Tree • In computer science, a tree is an abstract model of a hierarchical structure • A tree consists of nodes with a parent-child relation • Applications: • Organization charts • File systems • Programming environments CSC311: Data Structures

  3. A C D B E G H F K I J Tree Terminology • Root: node without parent (A) • Internal node: node with at least one child (A, B, C, F) • External node (a.k.a. leaf ): node without children (E, I, J, K, G, H, D) • Ancestors of a node: parent, grandparent, grand-grandparent, etc. • Depth of a node: number of ancestors • Height of a tree: maximum depth of any node (3) • Descendant of a node: child, grandchild, grand-grandchild, etc. • Subtree: tree consisting of a node and its descendants subtree CSC311: Data Structures

  4. Tree ADT • Query methods: • boolean isInternal(p) • boolean isExternal(p) • boolean isRoot(p) • Update method: • object replace (p, o) • Additional update methods may be defined by data structures implementing the Tree ADT • We use positions to abstract nodes • Generic methods: • integer size() • boolean isEmpty() • Iterator iterator() • Iterator positions() • Accessor methods: • position root() • position parent(p) • positionIterator children(p) CSC311: Data Structures

  5. Depth of a Node • The depth of a node v in a tree T is defined as: • If v is the root, then its depth is 0; • Otherwise, its depth is one plus the depth of its parent Algorithm depth(T, v) Input: Tree T and a node v Output: an integer that is the depth of v in T If v is the root of T then return 0 Else return 1 + depth(T, parent(v)) CSC311: Data Structures

  6. Height of a Node • The height of a node v in a tree T is defined as: • If v is an external, then its height is 0; • Otherwise, its height is one plus the maximum height of its children Algorithm height(T, v) Input: Tree T and a node v Output: an integer that is the height of v in T If v is an external of T then return 0 Else h0 for each child w of v in T do hmax(h, height(T,w)) return 1+h CSC311: Data Structures

  7. Features on Height • The height of a nonempty tree T is equal to the maximum depth of an external node of T • Let T be a tree with n nodes, and let cv denote the number if children of a node v of T. The summing over the vertices in T, vcv=n-1. CSC311: Data Structures

  8. 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 AlgorithmpreOrder(v) visit(v) foreachchild w of v preorder (w) 1 Make Money Fast! 2 5 9 1. Motivations 2. Methods References 6 7 8 3 4 2.3 BankRobbery 2.1 StockFraud 2.2 PonziScheme 1.1 Greed 1.2 Avidity CSC311: Data Structures

  9. 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 AlgorithmpostOrder(v) foreachchild w of v postOrder (w) visit(v) 9 cs16/ 8 3 7 todo.txt1K homeworks/ programs/ 4 5 6 1 2 Robot.java20K h1c.doc3K h1nc.doc2K DDR.java10K Stocks.java25K CSC311: Data Structures

  10. A C B D E F G I H Binary Trees • Applications: • arithmetic expressions • decision processes • searching • 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 CSC311: Data Structures

  11. +   2 - 3 b a 1 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)) CSC311: Data Structures

  12. 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? No Yes How about coffee? On expense account? Yes No Yes No Starbucks Spike’s Al Forno Café Paragon CSC311: Data Structures

  13. 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 BinaryTree ADT CSC311: Data Structures

  14. Properties of Proper Binary Trees • Properties: • e = i +1 • n =2e -1 • h  i • h  (n -1)/2 • e 2h • h log2e • h log2 (n +1)-1 • Notation n number of nodes e number of external nodes i number of internal nodes h height CSC311: Data Structures

  15. 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 AlgorithminOrder(v) ifhasLeft (v) inOrder (left (v)) visit(v) ifhasRight (v) inOrder (right (v)) 6 2 8 1 4 7 9 3 5 CSC311: Data Structures

  16. +   2 - 3 b a 1 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 AlgorithmprintExpression(v) ifhasLeft (v)print(“(’’) inOrder (left(v)) print(v.element ()) ifhasRight (v) inOrder (right(v)) print (“)’’) ((2  (a - 1)) + (3  b)) CSC311: Data Structures

  17. +   2 - 3 2 5 1 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 AlgorithmevalExpr(v) ifisExternal (v) returnv.element () else x evalExpr(leftChild (v)) y evalExpr(rightChild (v))  operator stored at v returnx  y CSC311: Data Structures

  18. 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) +   L R B 2 - 3 2 5 1 CSC311: Data Structures

  19. Template Method Pattern public abstract class EulerTour{ protected BinaryTree tree;protected voidvisitExternal(Position p, Result r) { }protected voidvisitLeft(Position p, Result r) { }protected voidvisitBelow(Position p, Result r) { }protected voidvisitRight(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; } … • 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 CSC311: Data Structures

  20. 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 EvaluateExpressionextends EulerTour{ protected voidvisitExternal(Position p, Result r) {r.finalResult = (Integer) p.element(); } protected voidvisitRight(Position p, Result r) {Operator op = (Operator) p.element();r.finalResult = op.operation( (Integer) r.leftResult, (Integer) r.rightResult ); } … } CSC311: Data Structures

  21. Linked Structure for Trees • A node is represented by an object storing • Element • Parent node • Sequence of children nodes • Node objects implement the Position ADT B   A D F B F A D   C E C E CSC311: Data Structures

  22. D C A B E 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 A D     C E CSC311: Data Structures

  23. A … B D C E F J G H Array-Based Representation of Binary Trees • nodes are stored in an array 1 2 3 • 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 4 5 6 7 10 11 CSC311: Data Structures

  24. Array-Based Representation of Binary Trees: Properties • Let n be the number of nodes of a binary tree T • Let pM be the maximum value of rank(v) over all the nodes of T • The array size N = pM+1 • In the worst case, N = 2n CSC311: Data Structures

More Related