Introduction to Trees
Tree example
• Consider this program structure diagram as
itself a data structure.
main
readin
process
sort
lookup
print
Terminology
• Node - an element of a tree
• Root node - the single node at level 0
• Child node - nodes at level 1 or lower
(descending from a parent node). Note: a node
can have only one parent.
Terminology (continued)
• Parent node - a node at one level associated
with nodes at a lower level (children).
• Note: nodes without children are called
leaves.
• Every node of a tree is the root of a subtree.
• As you can see by the diagram of a tree, its
structure is highly recursive. Therefore, as
you would expect, the procedures and
functions that manipulate trees are also
recursive in nature.
The tree as an ADT
• Fundamental operations
Create(Root)
Empty(Root)
Find(Root,Target,TargetLoc)
Add(Root,Node)
Delete(Root,Node)
Traverse(Root)
Binary Trees
• This (next slide) is an example of a binary
tree (ie. one in which each node has no
more than two children)
Binary tree example
(see previous tree)
• This tree also has the property that each
node is greater than either of its children.
Another name for it is a heap (not to be
confused with the system heap).
Question:
• What is the hierarchical ordering principal
for this tree?
• (see next slide)
What is the ordering property?
Answer:
• Each node is greater than all of the nodes in
its left subtree and less than all of the nodes
in its right subtree.
• This is called its ordering property.
Trees representing arithmetic
expressions.
• For example: (A-B)+(C*(E/F))
Example
• compare this tree to a tree for the expression
(A-B)+(C*E/F)
• Notice how small changes in the order of
operations (like removing a set of
parentheses) make major changes in the
structure of the tree.
Reverse Polish Again!?!
• Recall that expressions are easily evaluated
using a stack if they are available in postfix
form: AB-CEF/*+
• Trees can be traversed in such a way as to
produce the postfix form. eg. a postorder
traversal yields the postfix form of the
expression.
• More on this later.
Implementing Binary Trees
• Two methods:
• 1. Linear representation - array
• 2. Linked representation - pointers
Linear representation (Depth=3)
• 1. Allocate an array of size 2^(d+1)-1
• 2. Store root in location 1
• 3. For node in location n, store left child in
location 2n, right child in location 2n+1
Tradeoffs
• 1. Fast access (given a node, its children
and parent can be found very quickly)
• 2. Slow updates (inserts and deletions
require physical reordering)
• 3. Wasted space (partially filled trees)
Linked Representation
• Use records with pointer fields
(A-B)+(C*(E/F))
Using an array of records
• The array implementation of this ADT looks
like this (next slide)
• Insertions and deletions involve only
manipulation of pointers
Array of structures
Insertion (A-B)+(P-C*(E/F))
Deletion (A-B)+(P-E/F)
• The changes to the array of records look
like this after both of the operations
(insertion of -P and deletion of *C) have
been performed.
Tradeoffs
• 1. Faster updates
• 2. Extra memory for pointers
• 3. Wasted space for nil pointers (can be
corrected by threading)
• 4. Difficult to determine a node's
parent
(corrected by adding a parent pointer)
Traversing Binary Trees
• A tree traversal visits each node of a tree
exactly once
Modes of traversal
• When visiting a node we have three choices
• 1. Process the data
• 2. Remember location of the current node and process
nodes in the left subtree
• 3. Remember location of the current node and process
nodes in the right subtree
The choice made dictates the order of node processing for
the entire tree
Example tree (T)
Steps for a Preorder traversal of a
binary tree
• 1. Process root
• 2. Do a preorder traversal of the nodes
subtree(recursively)
in the root's left
• 3. Do a preorder traversal of the nodes
subtree (recursively)
in the root's right
• Assume the we have a procedure called Process that
simply writes out the data contained in any given node.
• Then, using process, a preorder traversal of tree T produces
+=AB*C/EF (the prefix form of (A-B)+C*(E/F))
Steps for an Inorder traversal of a
binary tree
• 1. Recursively visit left subtree
• 2. Process root
• 3. Recursively visit right sub-tree
Steps for a Postorder traversal of
a binary tree
• 1. Recursively visit left subtree
• 2. Recursively visit right subtree
• 3. Process Root
• A postorder traversal of T produces
AB- CEF/*+ (the postfix form)
• These traversals can be done on any binary
tree, not just expression trees.
Implementing lists using binary
trees
Implementing the List ADT
• Vehicle
Advantage
Disadvantage
• Array
Fast search
O(log2N)
O(N)
Fast inserts
and deletions
O(1)
Fast inserts
and deletions
O(log2N)
Slow inserts
and deletions
• Linked
• Binary
Tree
Slow search List
O(N)
Tree must be
balanced
The hierarchical relationship we employed is the ordering property.
Example tree: T1
• Inorder traversal of this tree gives
ADEFGHKMNPSTUVZ
So: An inorder traversal of a binary tree
with the ordering property visits the nodes
in ascending order.
• Adding a node to a binary tree with the
ordering property
• Follow the insertion rule: "If less than, go
left, otherwise go right."
Example: Add the letter R to the
previous tree.
• 1. Compare R to M (the root).
Since R > M, add R to the right subtree
• 2. Compare R to T (the root of the subtree).
Since R < T go left
• 3. Compare R to P. Since R > P go right
• 4. Compare R to S. Since R < S go left
• 5. Since the left subtree is NULL add R at
this point
Clearly, the procedure is recursive.
Adding ‘R’ to the tree
Efficiency of adding to a binary tree
• Question: How many comparisons did we
have to make?
Answer: 4
(ie. depth + 1)
Differing tree configurations
• Consider another tree: T2 representing the
same list:
Question
• How many comparisons do we have to
make to add the letter R?
Answer: 9
(ie. depth + 1)
Question:
• How do you minimize the depth of a binary
tree?
Answer: Make sure it is full, or balanced.
Definition:
• A balanced binary tree is one in which every node
above level depth-1 has exactly two children.
Depth to size comparisons
• When a binary tree of N nodes is balanced, no branch will
be longer than log(base 2)N+1. Thus, the efficiency of the
adding algorithm is O(log(base 2)N)
•
•
Depth
0
1
2
3
...
9
10
MaxN
1
3
7
15
1023
1 million
Suppose we add ‘Q’ to T1
Suppose we add Q to T1:
• Now T1 is not balanced.
• There are methods for balancing trees.
Recall the binary search of an
array
Binary similarities
• Each probe into the array is analogous to a
recursive descent in the search of a binary
tree. (both are O(log2N))
Deleting from a tree
For example, remove T from tree
T1.
• The result becomes
Deletion strategies
• Requirement: The resulting tree must have
the ordering property.
• One method is to find the largest item in
T1's left sub-tree and replace T with it.
Three special cases which might
occur:
• 1. Node to be deleted has a left child
• 2. Node to be deleted has a right child
but no left child
• 3. Node to be deleted has no children
Case 1:
• Suppose P points to the node to be deleted.
There are two important subcases
• 1.a
P->Left has no right child
• 1.b
P->Left has a right child
Case 1a
Case 1b
Case 2
Case 3
List comparison
• Tradeoffs
• adding
searching
Linked List
O(1)
O(N)
• user
1 ptr/node
memory
• system stack
minimal
Binary Tree
O(1) & deleting
O(log2N) balanced
O(N) worst case
2 ptrs/node
(many NULL)
recursion
(remedy - threading)
General Trees
General Trees
• So far we have been studying binary trees, general trees
however can have more than two children for each node.
Question: Does the former restriction to binary trees mean
that we cannot apply what we have learned to general
trees?
Answer: No! As long as we are willing to convert general
trees to binary ones.
Binary version of general tree
Preorder Traversal
• (Root, Left, Right)
• JBDNEPQKLMCXRT
Processing order
• 1. Process root
2. Recursively traverse the left-most subtree
3. Recursively traverse the next subtree to the right
4. Repeat step 3 until there are no more subtrees
Postorder Traversal
• (Left, Right, Root)
• QPENDLXRCTMKBJ
• Note that this order on the general tree can
be described by:
1. Start at the leaves and work up
2. Process a node after all nodes
below it have been processed