Make Money Fast!
Stock
Fraud
Ponzi
Scheme
Bank
Robbery
Chapter 7:Trees
Nancy Amato
Parasol Lab, Dept. CSE, Texas A&M University
Acknowledgement: These slides are adapted from slides provided with Data Structures and
Algorithms in C++, Goodrich, Tamassia and Mount (Wiley 2004)
http://parasol.tamu.edu
Outline and Reading
• Tree Definitions and ADT (§7.1)
• Tree Traversal Algorithms for General Trees
(preorder and postorder) (§7.2)
• BinaryTrees (§7.3)
• Traversals of Binary Trees (preorder, inorder, postorder, and
Euler Tour) (§7.3.6)
• Template method pattern (§7.3.7)
• Data structures for trees (§7.1.4 and §7.3.4)
• C++ implementation (§7.1.3 and §7.3.2)
Trees
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
US
Europe
Trees
Manufacturing
International
Asia
Laptops
R&D
Desktops
Canada
3
Tree Terminology
• Subtree: tree consisting of
• Root: node without parent (A)
a node and its
• Internal node: node with at least one
descendants
child (A, B, C, F)
A
• Leaf (aka External node): node
without children (E, I, J, K, G, H, D)
• Ancestors of a node: parent,
grandparent, great-grandparent, etc.
C
B
• Depth of a node: number of
ancestors
G
F
H
• Height of a tree: maximum depth of E
any node (3)
• Descendant of a node: child,
I
J
K
grandchild, great-grandchild, etc.
subtee
Trees
D
4
Exercise: Trees
• Answer the following questions about
the tree shown on the right:
• What is the size of the tree (number of
nodes)?
• Classify each node of the tree as a root,
leaf, or internal node
• List the ancestors of nodes B, F, G, and
A. Which are the parents?
• List the descendents of nodes B, F, G,
and A. Which are the children?
• List the depths of nodes B, F, G, and A.
• What is the height of the tree?
• Draw the subtrees that are rooted at
node F and at node K.
Trees
A
B
E
C
F
I
J
G
D
H
K
5
Tree ADT
• We use positions to abstract
nodes
• Generic methods:
•
•
•
•
integer size()
boolean isEmpty()
objectIterator elements()
positionIterator positions()
• Query methods:
•
•
•
boolean isInternal(p)
boolean isLeaf (p)
boolean isRoot(p)
• Update methods:
•
•
swapElements(p, q)
object replaceElement(p, o)
• Additional update methods
• Accessor methods:
• position root()
• position parent(p)
• positionIterator children(p)
Trees
may be defined by data
structures implementing the
Tree ADT
6
A Linked Structure for General Trees
• A node is represented by
an object storing
• Element
• Parent node
• Sequence of children
nodes

B

• Node objects implement
the Position ADT
A
B
D
A
C

D
F
F

E
C
Trees

E
7
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
Algorithm preOrder(v)
visit(v)
for each child w of v
preOrder(w)
1
Make Money Fast!
2
5
1. Motivations
9
2. Methods
3
4
1.1 Greed
1.2 Avidity
6
2.1 Stock
Fraud
Trees
7
2.2 Ponzi
Scheme
References
8
2.3 Bank
Robbery
8
Exercise: Preorder Traversal
• In a preorder traversal, a node is
visited before its descendants
• List the nodes of this tree in
preorder traversal order.
A
B
E
Algorithm preOrder(v)
visit(v)
for each child w of v
preOrder (w)
Trees
C
F
I
J
G
D
H
K
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
Algorithm postOrder(v)
for each child w of v
postOrder(w)
visit(v)
9
cs16/
3
8
7
homeworks/
todo.txt
1K
programs/
1
2
h1c.doc
3K
h1nc.doc
2K
4
DDR.java
10K
Trees
5
Stocks.java
25K
6
Robot.java
20K
10
Exercise: Postorder Traversal
• In a postorder traversal, a node
A
is visited after its descendants
• List the nodes of this tree in
postorder traversal order.
B
E
Algorithm postOrder(v)
for each child w of v
postOrder(w)
visit(v)
Trees
C
F
I
J
G
D
H
K
11
Binary Tree
• A binary tree is a tree with the
following properties:
• Applications:
• Each internal node has two children
• 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
arithmetic expressions
decision processes
searching
•
A
B
D
E
H
Trees
C
F
G
I
12
Arithmetic Expression Tree
• Binary tree associated with an arithmetic expression
• internal nodes: operators
• leaves: operands
• Example: arithmetic expression tree for the
expression (2  (a - 1) + (3  b))
+


-
2
a
3
b
1
Trees
13
Decision Tree
• Binary tree associated with a decision process
• internal nodes: questions with yes/no answer
• leaves: decisions
• Example: dining decision
Want a fast meal?
No
Yes
How about coffee?
On expense account?
Yes
No
Yes
Starbucks
Spike’s
Trees
Al Forno
No
Café Paragon
14
Properties of Binary Trees
• Properties:
• Notation
n number of nodes
l number of leaves
i number of internal nodes
h height
•
•
•
•
•
•
•
Trees
l=i+1
n = 2l - 1
hi
h  (n - 1)/2
l  2h
h  log2 l
h  log2 (n + 1) - 1
15
BinaryTree ADT
• The BinaryTree ADT
extends the Tree
ADT, i.e., it inherits
all the methods of
the Tree ADT
• Additional methods:
• Update methods
may be defined by
data structures
implementing the
BinaryTree ADT
• position leftChild(p)
• position rightChild(p)
• position sibling(p)
Trees
16
A Linked Structure for Binary Trees
• A node is represented by
an object storing
•
•
•
•

Element
Parent node
Left child node
Right child node
B
• Node objects implement
the Position ADT

B
A

A
D
C
D

E
Trees

C


E
17
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
6
Algorithm inOrder(v)
if isInternal(v)
inOrder(leftChild(v))
visit(v)
if isInternal(v)
inOrder(rightChild(v))
2
8
1
4
3
7
9
5
Trees
18
Exercise: Inorder Traversal
• In an inorder traversal a node is
visited after its left subtree and
before its right subtree
• List the nodes of this tree in
inorder traversal order.
A
B
E
Algorithm inOrder(v)
if isInternal(v)
inOrder(leftChild(v))
visit(v)
if isInternal(v)
inOrder(rightChild(v))
Trees
C
F
I
G
H
J
19
Exercise: Preorder & InOrder Traversal
• Draw a (single) binary tree T, such that
• Each internal node of T stores a single character
• A preorder traversal of T yields EXAMFUN
• An inorder traversal of T yields MAFXUEN
Trees
20
Print Arithmetic Expressions
Algorithm printExpression(v)
if isInternal(v)
print(“(’’)
• print operand or operator when
visiting node
printExpression(leftChild(v))
• print “(“ before traversing left
print(v.element())
subtree
if isInternal(v)
• print “)“ after traversing right
printExpression(rightChild(v))
subtree
print (“)’’)
• Specialization of an inorder
traversal
+


-
2
a
3
b
((2  (a - 1)) + (3  b))
1
Trees
21
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
3
2
1
Trees
22
Exercise: Arithmetic Expressions
• Draw an expression tree that has
• Four leaves, storing the values 1, 5, 6, and 7
• 3 internal nodes, storing operations +, -, *, /
(operators can be used more than once, but each
internal node stores only one)
• The value of the root is 21
Trees
23
Euler Tour Traversal
• Generic traversal of a binary tree
• Includes as 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
5
Trees
3
2
1
24
Euler Tour Traversal
Algorithm eulerTour(T,p)
left-visit-action(p)
if isInternal(p)
eulerTour(T,p.left()
bottom-visit-action(p)
if isInternal(p)
eulerTour(T,p.right())
right-visit-action(p)
End Algorithm
L
+
 R
B
-
2
5
Trees

3
1
2
25
Print Arithmetic Expressions
• Specialization of an Euler Tour Algorithm printExpression(T,p)
if isExternal(p) then
traversal
print value stored at p
• Left-visit-action: if node is
internal, print “(“
Else
• Bottom-visit-action: print value
print “(“
or operator stored at node
printExpression(T,p.left())
• Right-visit-action: if node is
Print the operator stored at p
internal, print “)”
printExpression(T,p.right())
+
print “)”
Endif

 End Algorithm
-
2
a
3
b
((2  (a - 1)) + (3  b))
1
Trees
26
Template Method Pattern
•
•
•
•
class EulerTour {
Generic algorithm that can protected:
be specialized by
BinaryTree* tree;
redefining certain steps
virtual void visitExternal(Position p, Result r) { }
virtual void visitLeft(Position p, Result r) { }
Implemented by means of
virtual void visitBelow(Position p, Result r) { }
an abstract C++ class
virtual void visitRight(Position p, Result r) { }
Visit methods that can be
int eulerTour(Position p) {
redefined by subclasses
Result r = initResult();
if (tree–>isExternal(p)) { visitExternal(p, r); }
Template method eulerTour
else {
• Recursively called on the
visitLeft(p, r);
left and right children
r.leftResult = eulerTour(tree–>leftChild(p));
• A Result object with fields
visitBelow(p, r);
leftResult, rightResult and
r.rightResult = eulerTour(tree–>rightChild(p));
finalResult keeps track of
visitRight(p, r);
the output of the recursive
return r.finalResult;
calls to eulerTour
} // … other details omitted
Trees
27
Specializations of EulerTour
• We show how to
specialize class EulerTour
to evaluate an arithmetic
expression
• Assumptions
• External nodes support a
function value(), which
returns the value of this
node.
• Internal nodes provide a
function operation(int,
int), which returns the
result of some binary
operator on integers.
class EvaluateExpression
: public EulerTour {
protected:
void visitExternal(Position p, Result r) {
r.finalResult = p.element().value();
}
void visitRight(Position p, Result r) {
Operator op = p.element().operator();
r.finalResult = p.element().operation(
r.leftResult, r.rightResult);
}
};
// … other details omitted
Trees
28