Trees. What is a Tree In computer science, a tree is an abstract model of a hierarchical structure A...

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

Last Update: Oct 16, 2014 Trees 2

Computers”R”Us

Sales

R&D

Manufacturing

Laptops

Desktops

CAN

International

Europe

Asia

USA

Tree TerminologyFor a node x:• Ancestors: x, parent, grandparent, great-grandparent, etc.• Descendants: x, children, grandchildren, great-grandchildren, etc.• Proper ancestors/descendants: exclude x itself.• Depth: number of proper ancestors of x.

For a tree:• Root: node without parent (A)• Internal node: node with at least one child

(A, B, C, F)• External node (aka, leaf ): node without

children (E, I, J, K, G, H, D)• Height: maximum node depth (3)• Subtree: tree consisting of a node and

its descendants


A

B DC

G HE F

I J K

A recursive view of Trees


v

T1 T2 Tk

Tree ADT• We use positions to abstract

nodes• Generic methods:

– integer size()– boolean isEmpty()– Iterator iterator()– Iterable positions()

• Accessor methods:– position root()– position parent(p)– Iterable children(p)– Integer numChildren(p)


• Query methods: boolean isInternal(p) boolean isExternal(p) boolean isRoot(p)

• Additional update methods may be defined by data structures implementing the Tree ADT

6

Java Tree interface

Last Update: Oct 16, 2014 Trees

Tree Traversals• A traversal method is a systematic way to explore the

tree structure by visiting its nodes in a specific order.• Very useful computational tool with many applications.• Important tree traversals:– Preorder – Postorder– Inorder– Euler tour (generalizes the above three)– Level order (aka, Breadth First Search) not shown in these slides.

Generalized BFS on graphs will be discussed later in the course.


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


Make Money Fast!

1. Motivations

References

2. Methods

2.1 StockFraud

2.2 Ponzi

Scheme

1.1 Greed

1.2 Avidity

2.3 Bank

Robbery

1

2

3

5

4 6 7 8

9

Algorithm preOrder(v)visit(v)for each child w of v

preorder (w)

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)

EECS2011/

assignments/

todo.txt

1K

programs/

LinOpt.java

10K

Stocks.java

25K

A1.doc

3K

A2.doc

2K

Robot.java

20K

9

3

1

7

2 4 5 6

8

Binary Trees A binary tree is a tree such that:

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 A leaf node has no children

Recursive definition of a binary tree T: T consists of an external root node, or T has internal root whose left and right

subtrees are binary trees.


Applications: arithmetic expressions decision processes searching

A

B C

F GD E

H I J

A recursive viewof Binary Trees


v

left subtree

ofv

node

right subtree

ofv

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

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?

Starbucks Chipotle Gracie’s Café Paragon

Yes No

Yes No Yes No

Properties of Proper Binary TreesNotation:

n number of nodese number of external nodesi number of internal nodesh height


Properties: e = i + 1 n = i + e = 2e - 1 h i h (n - 1)/2 e 2h

h log2 e h log2 (n + 1) - 1

BinaryTree ADT• The BinaryTree ADT

extends the Tree ADT, i.e., inherits all methods of Tree ADT

• Additional methods:position left(p)position right(p)position sibling(p)boolean isInternal(p)boolean isExternal(p)

• The above position methods return null when there is no left, right, or sibling of p, respectively

• Update methods may be defined by data structures implementing the BinaryTree ADT


Inorder Traversal• In an inorder traversal a node is

visited after its left subtree and before its right subtree

• Application: draw a binary tree.Planar node coordinates:

x(v) = inorder rank of vy(v) = depth of v


Algorithm inOrder(v)if isInternal(v)then inOrder( left(v) )visit(v)if isInternal(v)then inOrder( right(v) )

3

1

2

5

6

7 9

8

4

Print Arithmetic ExpressionsSpecialization of inorder traversal– print operand or operator when

visiting node– print “(“ before traversing left

subtree– print “)“ after traversing right

subtree


Algorithm printExpr(v)if isInternal(v) then

print( “(” )printExpr ( left(v) )

print( v.element () )if isInternal(v) then

printExpr ( right(v) )print ( “)” )

+

-2

a 1

3 b ((2 (a - 1)) + (3 b))

Evaluate Arithmetic Expressions• Specialization of postorder:

– recursive method returning the value of a subtree

– when visiting an internal node, combine the values of its left & right subtrees

Last Update: Oct 16, 2014

Trees 18

Algorithm evalExpr(v)if isExternal (v) then

return v.element()else

x evalExpr(left(v))y evalExpr(right(v)) v.element()

return x y

+

-2

5 1

3 2

Euler Tour Traversal• Generic traversal of a binary tree• Includes as special cases: preorder, postorder and inorder • Walk around the tree and visit each node three times:– on the left (preorder)– from below (inorder)– on the right (postorder)


+

-2

5 1

3 2

L

BR

20

Template Method Pattern• Generic algorithm that can be

specialized by redefining certain steps

• Implemented by means of an abstract Java class

• Visit methods can be redefined by subclasses

• Template method eulerTour– Recursively called on the left

and right children– A local variable r of type

Result 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(); // local

variableif 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;

} }


21

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

); }

// … the rest omitted …

}


Linked Structure for Trees• A node is represented by an

object storing– Element– Parent node– list of children nodes

• Node objects implement the Position ADT


B

DA

C E

F

B

A D F

C

E

elem

ent

pare

nt

child

ren

child list

node

Linked Structure for Binary Trees


B

DA

C E

B

A D

C E

• A node is represented by an object

storing– Element– Parent node– left child node– Right child node

• Node objects implement the Position ADT

Array-Based Representation of Binary TreesNodes are stored in an array A


Node v is stored at A[rank(v)] rank(root) = 0 rank(left(node)) = 2 rank(node) + 1 rank(right(node)) = 2 rank(node) + 2 rank(parent(node)) = (rank(node) -1)/2

0

1 2

5 63 4

9 10

a

hg

fe

d

c

b

j

a b d g h ……

1 2 9 100

25

ComparisonLinked Structure• Requires explicit

representation of 3 links per position:– parent, left child, right child

• Data structure grows as needed – no wasted space.

Array• Parent and children are

implicitly represented:– Lower memory requirements

per position

• Memory requirements determined by height of tree. If tree is sparse, this is highly inefficient.



Summary• The Tree ADT, tree terminologies, and Java interface• Tree Traversals

– Preorder– Postorder– Inorder– Euler Tour– Level order (aka, breadth first search)

• Binary trees: properties & some applications• Linked list & array based representations of trees.

Trees. What is a Tree In computer science, a tree is an abstract model of a hierarchical structure A...

Documents

Transcript of Trees. What is a Tree In computer science, a tree is an abstract model of a hierarchical structure A...