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. 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
Computers”R”Us
Sales
R&D
Manufacturing
Laptops
Desktops US
International
Europe
Asia
Canada
Trees
CSC311: Data Structures

3. Tree Terminology subtree 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 A B D C G H E F I J K
subtree
Trees
CSC311: Data Structures

4. 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)
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
Trees
CSC311: Data Structures

5. Depth of a Node The depth of a node v in a tree T is defined as:
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))
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
Trees
CSC311: Data Structures

6. Height of a Node The height of a node v in a tree T is defined as:
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
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
Trees
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.
Trees
CSC311: Data Structures

8. Preorder Traversal Algorithm preOrder(v) visit(v)
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
Algorithm preOrder(v)
visit(v)
for each child w of v
preorder (w) 1
Make Money Fast! 2 5 9
1. Motivations
2. Methods
References 6 7 8 3 4
2.1 Stock Fraud
2.2 Ponzi Scheme
2.3 Bank Robbery
1.1 Greed
1.2 Avidity
Trees
CSC311: Data Structures

9. Postorder Traversal Algorithm postOrder(v) for each child w of v
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) 9
cs16/ 8 3 7
todo.txt 1K
homeworks/
programs/ 1 2 4 5 6
h1c.doc 3K
h1nc.doc 2K
DDR.java 10K
Stocks.java 25K
Robot.java 20K
Trees
CSC311: Data Structures

10. 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 A B C F G D E H I
Trees
CSC311: Data Structures

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

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

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

15. Inorder Traversal Algorithm inOrder(v) if hasLeft (v)
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)) 6 2 8 1 4 7 9 3 5
Trees
CSC311: Data Structures

16. Print Arithmetic Expressions
Algorithm printExpression(v)
if hasLeft (v) print(“(’’)
inOrder (left(v))
print(v.element ())
if hasRight (v)
inOrder (right(v))
print (“)’’)
Specialization of an inorder traversal
print operand or operator when visiting node
print “(“ before traversing left subtree
print “)“ after traversing right subtree +  - 2 a 1 3 b
((2  (a - 1)) + (3  b))
Trees
CSC311: Data Structures

17. 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 5 1 3
Trees
CSC311: Data Structures

18. Euler Tour Traversal +   2 - 3 2 5 1
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
Trees
CSC311: Data Structures

19. 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; } …
Trees
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 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 ); } … }
Trees
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 A D F   C E C E
Trees
CSC311: Data Structures

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

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