Transcript Trees

Trees
Definition of a tree

A tree is like a binary tree, except that a node may have any
number of children
Depending on the needs of the program, the children may or may not be
ordered

Like a binary tree, a tree has a
root, internal nodes, and leaves
A

Each node contains an element
and has branches leading to other
nodes (its children)
B
C
D
E

Each node (other than the root)
has a parent
F G H
I
J
K

Each node has a depth (distance
from the root)
L
M
N

2
More definitions







An empty tree has no nodes
The descendents of a node are its children and the descendents
of its children
The ancestors of a node are its parent (if any) and the
ancestors of its parent
The subtree rooted at a node consists of the given node and all
its descendents
An ordered tree is one in which the order of the children is
important; an unordered tree is one in which the children of a
node can be thought of as a set
The branching factor of a node is the number of children it has
The branching factor of a tree is the average branching factor
of its nodes
3
Data structure for a tree





A node in a binary tree can be represented as follows:
class BinaryTreeNode {
Object value;
BinaryTreeNode leftChild, rightChild;
}
However, each node in a tree has an arbitrary number of children, so we need
something that will hold an arbitrary number of nodes, such as a Vector or an
ArrayList or a LinkedList
class TreeNode {
Object element;
Vector<TreeNode> children;
}
We can use an array, but that’s expensive if we need to add or delete children
If the order of children is irrelevant, we may use a Set instead of a Vector
If order of children matters, we cannot use a Set
4
General requirements for an ADT

The constructors and transformers must together be
able to create all legal values of the ADT



A constructor or transformer should never create an illegal
value
It’s nice if the constructors alone can create all legal values,
but sometimes this results in constructors with too many
parameters for reasonable convenience
The accessors must be able to extract any data needed
by the application
5
ADT for a tree

It must be possible to:

Construct a new tree





If a tree can be empty, this may require a header node
Add a child to a node
Get (iterate through) the children of a node
Access (get and set) the value in a node
It should probably be possible to:


Remove a child (and the subtree rooted at that child)
Get the parent of a node
6
A Tree ADT, I: Parents and values

Constructor:


Values:



public Tree(Object value)
public Object getValue()
public void setValue(Object value)
Parents and ancestors:


public Tree getParent()
public boolean hasAncestor(Tree ancestor)
7
A Tree ADT, II: children and siblings

Children:








public void addChild(Tree newChild)
public void addChildren(ArrayList newChildren)
public void detachFromParent()
public boolean hasChildren()
public ArrayList getChildren()
public Tree GetFirstChild()
public Tree getLastChild()
Siblings:




public boolean hasNextSibling()
public Tree getNextSibling()
public boolean hasPreviousSibling()
public Tree getPreviousSibling()
8
A Tree ADT, III: Iterator, other methods

Iterator (preorder traversal of the Tree):





Convenience methods:




public Iterator iterator()
public boolean hasNext()
public Object next()
public void remove()
public boolean isRoot()
public boolean isLeaf()
public int depth()
Standard methods:



public boolean equals(Object o)
public String toString()
public void print()
9
Traversing a tree

You can traverse a tree in preorder:
void preorderPrint(node) { // doesn’t use Tree.iterator()
System.out.println(node);
Iterator iter = node.children.iterator();
while (iter.hasNext()) {
preorderPrint(iter.next());
}
}

You can traverse a tree in postorder:
void postorderPrint(node) {
Iterator iter = node.children.iterator();
while (iter.hasNext()) {
postorderPrint(iter.next());
}
System.out.println(node);
}

You can’t usually traverse a tree in inorder

Why not?
10
Other tree manipulations

There’s really nothing new to talk about; you’ve
seen it all with binary trees

A tree consists of nodes, each node has references
to some other nodes—you know how to do all this
stuff

There are some useful algorithms for searching
trees, and with some modifications they also apply
to searching graphs

Let’s move on to some applications of trees
11
File systems

File systems are almost always implemented as a tree
structure


The nodes in the tree are of (at least) two types: folders (or
directories), and plain files
A folder typically has children—subfolders and plain files



A folder also contains a link to its parent—in both Windows and
UNIX, this link is denoted by ..
In UNIX, the root of the tree is denoted by /
A plain file is typically a leaf
12
Family trees

It turns out that a tree is not a good way to
represent a family tree



Every child has two parents, a mother and a father
Parents frequently remarry
An “upside down” binary tree almost works



Since it is a biological fact (so far) that every child has
exactly two parents, we can use left child = mother and
right child = father
The terminology gets a bit confusing
If you could go back far enough, it becomes a
mathematical certainty that the mother and father have
some ancestors in common
13
Part of a genealogy
Isaac
Steven
Paul
a
David
Chester
Danielle
Elaine
Eugene
Winfred
Carol
Pauline
14
Game trees



Trees are used heavily in implementing games, particularly
board games
A node represents a position on the board
The children of a node represent all the possible moves from
that position



More precisely, the branches from a node represent the possible moves;
the children represent the new positions
Planning ahead (in a game) means choosing a path through the
tree
However—



You can’t have a cycle in a tree
If you can return to a previous position in a game, you have a cycle
Graphs can have cycles
15
Binary trees for expressions

Ordered trees can be used to represent arithmetic expressions
+
2
+
2
2
The expression 2+2
*
+
*
3
4
The expression 2+3*4

2
4
3
The expression (2+3)*4
To evaluate an expression (given as a node):

If it is a leaf, the element in it specifies the value



If the element is a number, that number is the value
If the element is a variable, look up its value in a table
If it is not a leaf,

Evaluate the children and combine them according to the operation
specified by the element
16
(General) trees for expressions


You can use binary trees for expressions if you have only unary
and binary operators
Java has a ternary operator
if
?:
>
x
>
x y
y
The expression x > y ? x : y
x
=
=
y max x max y
The statement if (x > y) max = x;
else max = y;


Trees can be used to represent statements as well as
expressions
Statements can be evaluated as easily as expressions
17
More trees for statements
while (n >= 1) {
exp = x * exp;
n--;
}
for (int i = 0; i < n; i++)
a[i] = 0;
for
while
>=
n
=
;
1
=
exp
x
*
--
int
n
i
<
0 i
n
++
=
i
[] 0
a
i
exp
18
Writing compilers and interpreters

A compiler does three things:




An interpreter does three things:




Parses the input program (converts it into an abstract syntax tree)
(Optionally) optimizes the abstract syntax tree
Traverses the tree and outputs assembly language or machine code
to do the same operations
Parses the input program (converts it into an abstract syntax tree)
(Optionally) optimizes the abstract syntax tree
Traverses the tree in an order controlled by the node contents, and
performs the operations as it goes
Parsing is usually the hard part, but there is a very simple
technique (called recursive descent parsing) that can be
used if the language is carefully designed and you don’t
care too much about efficiency or good error messages
19
I’ll never need to write a compiler...



Are you sure?
If you can’t parse text inputs, you are limited to reading simple
things like numbers and Strings
If you can parse text input, you can make sense of:






tell Mary "Meet me at noon"
fire phasers at 3, 7
17.25, 0.203 + 8.97i, 0.95i
28°12"48'
3:30pm-5pm
Parsing is less important in these days of GUIs, but it’s still pretty
important

Java provides basic support for parsing with its StringTokenizer and
StreamTokenizer classes
20
The End
21