Module 4- Trees

• Introduction
• Terminology
• Binary Trees
• Properties of binary trees
• Array and Linked representations of binary tree
• Binary Tree Traversals
• Additional Binary Tree Operations
• Threaded Binary Trees
• Binary Search Trees
• Binary Search Trees operations
• Application of Trees-Evaluation of Expression
 Introduction (1/8)
• A tree structure means that the data are organized so
that items of information are related by branches
• Examples:
 Introduction (2/8)

• Definition (recursively): A tree is a finite set of one or

more nodes such that
• There is a specially designated node called root.
• The remaining nodes are partitioned into n>=0 disjoint set
T1,…,Tn, where each of these sets is a tree. T1,…,Tn are
called the subtrees of the root.
• Every node in the tree is the root of some subtree
 Introduction (3/8)
Terminology
•Node: The item of information plus the branches to other nodes
•Degree: The number of subtrees of a node
•Degree of a tree: The maximum of the degree of the nodes in the tree.
•Terminal nodes (or leaf): nodes that have degree zero or node with no
successor
•Nonterminal nodes: nodes that don’t belong to terminal nodes.
•Parent and Children: Suppose N is a node in T with left successor S1 and
right successor S2, then N is called the Parent (or father) of S1 and S2.
Here, S1 is called left child (or Son) and S2 is called right child (or Son) of
N.
Introduction (4/8)
Terminology (cont’d)
•Siblings: Children of the same parent are said to be siblings.
•Edge: A line drawn from node N of a T to a successor is called an
edge
•Path: A sequence of consecutive edges from node N to a node M is
called a path.
•Ancestors of a node: All the nodes along the path from the root to that
node.
•The level of a node: defined by letting the root be at level zero. If a
node is at level l, then it children are at level l+1.
•Height (or depth): The maximum level of any node in the tree
 Introduction (5/8)
• Example
A is the root node Property: (# edges) = (#nodes) - 1
B is the parent of D and E
C is the sibling of B
D and E are the children of B
D, E, F, G, I are external nodes, or leaves
A, B, C, H are internal nodes
The level of E is 3 Level
The height (depth) of the tree is 4 A
The degree of node B is 2 1
The degree of the tree is 3
B C
The ancestors of node I is A, C, H 2
The descendants of node C is F, G, H, I
H
3
D E F G
I
4
 Introduction (6/8)
Representation of Trees
• List Representation
• we can write of Figure 5.2 as a list in which each of the
subtrees is also a list
( A ( B ( E ( K, L ), F ), C ( G ), D ( H ( M ), I, J ) ) )
• The root comes first,
followed by a list of sub-trees
 Introduction (7/8)
• Representation Of Trees (cont’d)
• Left Child-
Right Sibling
Representation
 Introduction (8/8)
• Representation Of Trees (cont’d)
• Representation
As A Degree
Two Tree
Binary Trees (1/8)
• Binary trees are characterized by the fact that any node can have at
most two branches
• Definition (recursive):
• A binary tree is a finite set of nodes that is either empty or
consists of a root and two disjoint binary trees called the left
subtree and the right subtree
• Thus the left subtree and the right subtree are distinguished
A A

B B

• Any tree can be transformed into binary tree

• by left child-right sibling representation
 Binary Trees (2/8)
• Two special kinds of binary trees:
(a) skewed tree, (b) complete binary tree
• The all leaf nodes of these trees are on two adjacent levels
Binary Trees (3/8)
Properties of binary trees
Lemma [Maximum number of nodes]:
1. The maximum number of nodes on level i of a binary tree
is 2i-1, i 1.
2. The maximum number of nodes in a binary tree of depth
k is 2k-1, k1

Lemma [Relation between number of leaf nodes and

degree-2 nodes]:
For any nonempty binary tree, T, if n0 is the number of leaf
nodes and n2 is the number of nodes of degree 2, then n0 =
n2 + 1.
These lemmas allow us to define full and complete
binary trees
 Binary Trees (4/8)
• Definition:
• A full binary tree of depth k is a binary tree of death k having
2k-1 nodes, k  0.
• A binary tree with n nodes and depth k is complete iff its
nodes correspond to the nodes numbered from 1 to n in the
full binary tree of depth k.
• From Lemma 5.1, the
height of a complete
binary tree with n nodes
is log2(n+1)
 Binary Trees (5/8)
Binary tree representations (using array)
Lemma: If a complete binary tree with n nodes is represented
sequentially, then for any node with index i, 1  i  n, we have
1. parent(i) is at i /2 if i  1.
If i = 1, i is at the root and has no parent.
2. LeftChild(i) is at 2i if 2i  n.
If 2i  n, then i has no left child.
3. RightChild(i) is at 2i+1 if 2i+1  n.
If 2i +1  n, then i has no left child
A 1

[1] [2] [3] [4] [5] [6] [7] B 2 C 3

A B C — D — E
Level 1 D E
Level 2 Level 3 4 5 6 7
 Binary Trees (6/8)
• Binary tree representations (using array)
• Waste spaces: in the worst case, a skewed tree of depth k
requires 2k-1 spaces. Of these, only k spaces will be occupied
• Insertion or deletion
of nodes from the
middle of a tree
requires the
movement of
potentially many nodes
to reflect the change in
the level of these nodes
 Binary Trees (7/8)
• Binary tree representations (using link)
Binary Trees (8/8)
• Binary tree representations (using link)
Binary Tree Traversals (1/9)
• How to traverse a tree or visit each node in the tree
exactly once?
• There are six possible combinations of traversal
LVR, LRV, VLR, VRL, RVL, RLV
• Adopt convention that we traverse left before
right, only 3 traversals remain
LVR (inorder), LRV (postorder), VLR (preorder)

left_child data right_child

V
L: moving left : R: moving right
visiting
node
 Binary Tree Traversals (2/9)
• Arithmetic Expression using binary tree
• inorder traversal (infix expression)
A/B*C*D+E
• preorder traversal (prefix expression)
+**/ABCDE
• postorder traversal
(postfix expression)
AB/C*D*E+
• level order traversal
+*E*D/CAB
Binary Tree Traversals (3/9)
• Inorder traversal (LVR) (recursive version)

output A / B * C * D + E
:
ptr
L
V
R
Binary Tree Traversals (4/9)
• Preorder traversal (VLR) (recursive version)
output + * * / A B C D E
:

V
L
R
 Binary Tree Traversals (5/9)
• Postorder traversal (LRV) (recursive version)
output A B / C * D * E +
:

L
R
V
 Binary Tree Traversals (6/9)
• Iterative inorder traversal
• we use a stack to simulate recursion
5 4 11
8 3 14
2 17
1
A B
/ *C D
* E
+

L
V

output A / B*C * D + E node

:
 Binary Tree Traversals (7/9)
• Analysis of inorder2 (Non-recursive Inorder traversal)
• Let n be the number of nodes in the tree
• Time complexity: O(n)
• Every node of the tree is placed on and removed
from the stack exactly once
• Space complexity: O(n)
• equal to the depth of the tree which
(skewed tree is the worst case)
 Binary Tree Traversals (8/9)
• Level-order traversal
• method:
• We visit the root first, then the root’s left child, followed by the
root’s right child.
• We continue in this manner, visiting the nodes at each new level
from the leftmost node to the rightmost nodes
• This traversal requires a queue to implement
 Binary Tree Traversals (9/9)
• Level-order traversal (using queue)

output + * E * D / C A B
:
1 17 3 14 4 11 5
2 8
*+ E * D / C A B

FIFO

ptr
 Additional Binary Tree Operations (1/7)
• Copying Binary Trees
• we can modify the postorder traversal algorithm only
slightly to copy the binary tree

similar as
Program 5.3
 Additional Binary Tree Operations (2/7)
• Testing Equality
• Binary trees are equivalent if they have the same topology
and the information in corresponding nodes is identical
V L R

the same topology and data as Program 5.6

Additional Binary Tree Operations (3/7)
• Variables: x1, x2, …, xn can hold only of two possible
values, true or false
• Operators: (and), (or), ¬(not)
• Propositional Calculus Expression
• A variable is an expression
• If x and y are expressions, then ¬x, xy, xy are
expressions
• Parentheses can be used to alter the normal order of
evaluation (¬ >  > )
• Example: x1  (x2  ¬x3)
Additional Binary Tree Operations (4/7)
• Satisfiability problem:
• Is there an assignment to make an expression true?
• Solution for the Example x1  (x2  ¬x3) :
• If x1 and x3 are false and x2 is true
• false  (true  ¬false) = false  true = true
• For n value of an expression, there are 2n possible
combinations of true and false
 Additional Binary Tree Operations (5/7)
(x1  ¬x2)  (¬ x1  x3)  ¬x3

postorder traversal 

data  

value   X3

X1   X3

X2 X1
Additional Binary Tree Operations (6/7)
• node structure
• For the purpose of our evaluation algorithm, we assume
each node has four fields:

• We define this node structure in C as:

 Additional Binary Tree Operations (7/7)
• Satisfiability function
• To evaluate the tree is
easily obtained by
modifying the original L
recursive postorder R
V
traversal
TRUE
node

TRUE
FALSE

FALSE
TRUE T
TRUE

F
T TRUE FALSE FALSE
TRUE

FALSE F T TRUE
 Threaded Binary Trees (1/10)
• Threads
• Do you find any drawback of the above tree?
• Too many null pointers in current representation of binary
trees
n: number of nodes
number of non-null links: n-1
total links: 2n
null links: 2n-(n-1) = n+1
• Solution: replace these null pointers with some useful
“threads”
 Threaded Binary Trees (2/10)
• Rules for constructing the threads
• If ptr->left_child is null,
replace it with a pointer to the node that would be visited
before ptr in an inorder traversal
• If ptr->right_child is null,
replace it with a pointer to the node that would be visited
after ptr in an inorder traversal
 Threaded Binary Trees (3/10)
• A Threaded Binary Tree
root A
t: true  thread
f: false  child
dangling
f B f C

D t E t F G
dangling

inorder traversal:
H I
H D I B E A F C G
 Threaded Binary Trees (4/10)

• Two additional fields of the node structure, left-thread and right-

thread
• If ptr->left-thread=TRUE,
then ptr->left-child contains a thread;
• Otherwise it contains a pointer to the left child.
• Similarly for the right-thread
Threaded Binary Trees (5/10)
• If we don’t want the left pointer of H and the right pointer of G to be
dangling pointers, we may create root node and assign them pointing
to the root node
Threaded Binary Trees (6/10)
Inorder traversal of a threaded binary tree
• By using of threads we can perform an inorder traversal
without making use of a stack (simplifying the task)
• Now, we can follow the thread of any node, ptr, to the
“next” node of inorder traversal

1. If ptr->right_thread = TRUE, the inorder successor of ptr

is ptr->right_child by definition of the threads
2. Otherwise we obtain the inorder successor of ptr by
following a path of left-child links from the right-child of
ptr until we reach a node with left_thread = TRUE
 Threaded Binary Trees (7/10)
• Finding the inorder successor (next node) of a node
threaded_pointer insucc(threaded_pointer tree){
threaded_pointer temp;
temp = tree->right_child; tree
if (!tree->right_thread)
while (!temp->left_thread)
temp = temp->left_child;
return temp;
temp
}

Inorder
 Threaded Binary Trees (8/10)
• Inorder traversal of a threaded binary tree
void tinorder(threaded_pointer tree){
/* traverse the threaded binary tree inorder */

threaded_pointer temp = tree; output H D I B E A FC G

for (;;) { :
temp = insucc(temp);
if (temp==tree) tree
break;
printf(“%3c”,temp->data);
}
}

Time Complexity: O(n)

 Threaded Binary Trees (9/10)
Inserting A Node Into A Threaded Binary Tree
Insert child as the right child of node parent
1.change parent->right_thread to FALSE
2.set child->left_thread and child->right_thread to TRUE
3.set child->left_child to point to parent
4.set child->right_child to parent->right_child
5.change parent->right_child to point to child
 Threaded Binary Trees (10/10)
• Right insertion in a threaded binary tree
void insert_right(thread_pointer parent, threaded_pointer child){
/* insert child as the right child of parent in a threaded binary tree */
threaded_pointer temp; root
child->right_child = parent->right_child;
child->right_thread = parent->right_thread; A parent
child->left_child = parent; B
child->left_thread = TRUE;
parent->right_child = child; C X child
parent->right_thread = FALSE;
If(!child->right_thread){ A parent temp
temp = insucc(child); B child
temp->left_child = child; X
} C
} D
First Case E F
Second Case successor
Binary Search Trees (1/8)
Definition of binary search tree:
• Every element has a unique key
• The keys in a nonempty left subtree (right subtree) are
smaller (larger) than the key in the root of subtree
• The left and right subtrees are also binary search trees
 Binary Search Trees (2/8)
Example: (b) and (c) are binary search trees

medium

smaller larger
 Binary Search Trees (3/8)
• Search: Search(25) Search(76)

44

17 88

32 65 97

28 54 82

29 76

80
 Binary Search Trees (4/8)
• Searching a
binary search
tree

O(h)
 Binary Search Trees (5/8)
• Inserting into a binary search tree

An empty tree
 Binary Search Trees (6/8)
• Deletion from a binary search tree
• Three cases should be considered
• case 1. leaf  delete
• case 2.
one child  delete and change the pointer to this child
• case 3. two child  either the smallest element in the right
subtree or the largest element in the left subtree
 Binary Search Trees (7/8)

• Height of a binary search tree

• The height of a binary search tree with n elements can
become as large as n.
• It can be shown that when insertions and deletions are
made at random, the height of the binary search tree is
O(log2n) on the average.
• Search trees with a worst-case height of O(log2n) are called
balance search trees
 Binary Search Trees (8/8)
• Time Complexity
• Searching, insertion, removal
• O(h), where h is the height of the tree
• Worst case - skewed binary tree
• O(n), where n is the # of internal nodes
• Prevent worst case
• rebalancing scheme
• AVL, 2-3, and Red-black tree