Download Trees - faculty.cs.tamu.edu

Trees
Outline and Reading
• Tree Definitions and ADT (§7.1)
• Tree Traversal Algorithms for General Trees (preorder
and postorder) (§7.2)
• BinaryTrees (§7.3)
• Data structures for trees (§7.1.4 and §7.3.4)
• Traversals of Binary Trees (preorder, inorder,
postorder) (§7.3.6)
• Euler Tours (§7.3.7)
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
Computers”R”Us
Sales
US
Europe
Manufacturing
International
Asia
Laptops
Canada
Desktops
R&D
Tree Terminology
• Subtree: tree consisting of a
• Root: node without parent (A)
node and its descendants
• Internal node: node with at least one
child (A, B, C, F)
• Leaf (aka External node): node without
A
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
• Height of a tree: maximum depth of
any node (3)
G
E
F
H
• Descendant of a node: child,
grandchild, great-grandchild, etc.
I
J
K
subtee
D
Exercise: Trees
• Answer the following questions about
the tree shown on the right:
– What is the size of the tree (number of
nodes)?
B
– 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?
E
– List the descendents of nodes B, F, G,
and A. Which are the children?
– List the depths of nodes B, F, G, and A.
I
– What is the height of the tree?
– Draw the subtrees that are rooted at
node F and at node K.
A
C
F
J
G
K
D
H
Tree ADT
• We use positions to abstract
nodes
• Generic methods:
•
•
•
•
integer size()
boolean isEmpty()
objectIterator elements()
positionIterator positions()
• Accessor methods:
• position root()
• position parent(p)
• positionIterator children(p)
•
•
•
Query methods:
•
boolean isInternal(p)
•
boolean isLeaf (p)
•
boolean isRoot(p)
Update methods:
•
swapElements(p, q)
•
object replaceElement(p, o)
Additional update methods may
be defined by data structures
implementing the Tree ADT
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

D
F
B
D
A

F
C
C
E

E
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

D
F
B
D
A

F
C
C
E

E
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

D
F
B
D
A

F
C
C
E

E
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

D
F
B
D
A

F
C
C
E

E
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
Data Structures & Algorithms
2
2. Object-Oriented Design
1. A C++ Primer
3
1.1 Basic C++
Programming Elements
9
5
4
1.2 Expressions
6
2.1 Goals, Principles,
and Patterns
7
2.2 Inheritance and
Polymorphism
Bibliography
8
2.3 Templates
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)
C
F
I
J
G
K
D
H
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
5
Stocks.java
25K
6
Robot.java
20K
Exercise: Postorder Traversal
•
•
A
In a postorder traversal, a node 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)
C
F
I
J
G
K
D
H
Binary Tree
• A binary tree is a tree with the
following properties:
•
• 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
Applications:
•
arithmetic expressions
•
decision processes
•
searching
A
B
C
D
E
H
F
I
G
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
1
b
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?
Yes
Starbucks
On expense account?
No
Antonio’s
Yes
Veritas
No
Chili’s
Properties of Binary Trees
• Notation
n number of nodes
l number of leaves
i number of internal
nodes
h height
•
Properties:
•
l=i+1
•
n = 2l - 1
•
hi
•
h  (n - 1)/2
•
l  2h
•
h  log2 l
•
h  log2 (n + 1) - 1
Properties of Binary Trees
• Full (or proper) binary tree
• All nodes have either 0 or 2 children

Properties of Binary Trees
• Complete binary tree with height h
• All 2h-1 nodes exist at height h-1
• Nodes at level h fill up left to right

BinaryTree ADT
• The BinaryTree ADT
extends the Tree ADT,
i.e., it inherits all the
methods of the Tree
ADT
• Additional methods:
• position leftChild(p)
• position rightChild(p)
• position sibling(p)
• Update methods may
be defined by data
structures
implementing the
BinaryTree ADT
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

C


E
Inorder Traversal
• In an inorder traversal a node Algorithm inOrder(v)
is visited after its left subtree
if isInternal(v)
and before its right subtree
inOrder(leftChild(v))
visit(v)
• Application: draw a binary tree
• x(v) = inorder rank of v
• y(v) = depth of v
if isInternal(v)
inOrder(rightChild(v))
6
2
8
1
4
3
7
5
9
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))
C
F
I
G
K
H
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
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
3
b
((2  (a - 1)) + (3  b))
a
1
Evaluate Arithmetic Expressions
Algorithm evalExpr(v)
if isLeaf(v)
return v.element()
else
x  evalExpr(leftChild(v))
y  evalExpr(rightChild(v))
  operator stored at v
return x  y
• Specialization of a postorder
traversal
• recursive method returning
the value of a subtree
• when visiting an internal
node, combine the values of
the subtrees
+


-
2
a
3
1
b
Exercise: Arithmetic Expressions
• Draw an expression tree that has
• Four leaves, storing the values 2, 4, 8, and 8
• 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 24
Exercise: Arithmetic Expressions
• Draw an expression tree that has
• Four leaves, storing the values 2, 4, 8, and 8
• 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 24
+
+
8

8
2
4
Exercise: Arithmetic Expressions
• Draw an expression tree that has
• Four leaves, storing the values 1, 3, 4, and 8
• 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 24
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
3
1
2
Euler Tour Traversal
Algorithm eulerTour(p)
left-visit-action(p)
if isInternal(p)
eulerTour(p.left())
bottom-visit-action(p)
if isInternal(p)
eulerTour(p.right())
right-visit-action(p)
End Algorithm
+
L


R
B
-
2
5
3
1
2
Print Arithmetic Expressions
•
Algorithm printExpression(p)
if isExternal(p) then
print value stored at p
Else
print “(“
printExpression(p.left())
Print the operator stored
at p
printExpression(p.right())
print “)”
Endif
End Algorithm
Specialization of an Euler Tour
traversal
•
•
•
Left-visit-action: if node is
internal, print “(“
Bottom-visit-action: print value
or operator stored at node
Right-visit-action: if node is
internal, print “)”
+


-
2
3
b
((2  (a - 1)) + (3  b))
a
1
Template Method Pattern
• Generic algorithm that can
be specialized by redefining
certain steps
• Implemented by means of
an abstract C++ 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
class EulerTour {
protected:
BinaryTree* tree;
virtual void visitLeaf(Position p, Result r) { }
virtual void visitLeft(Position p, Result r) { }
virtual void visitBelow(Position p, Result r) { }
virtual void visitRight(Position p, Result r) { }
int eulerTour(Position p) {
Result r = initResult();
if (tree–>isLeaf(p)) {
visitLeaf(p, r);
return r.finalResult;
} else {
visitLeft(p, r);
r.leftResult = eulerTour(tree–>leftChild(p));
visitBelow(p, r);
r.rightResult = eulerTour(tree–>rightChild(p));
visitRight(p, r);
return r.finalResult;
} // … other details omitted
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 visitLeaf(Position p, Result r) {
r.finalResult = p.element().value();
}
void visitRight(Position p, Result r) {
Operator op = p.element().operator();
r.finalResult = op.operation(
r.leftResult, r.rightResult);
}
// … other details omitted
};