DS Module 3

Trees
 Trees
DEFINITION
• 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.
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
• Non terminal 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 of S1 and
S2. Here, S1 is called left child and S2 is called right child of N.
• 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
• A is the root node
• B is the parent of E and F
• C and D are the sibling of B
• E and F are the children of B
• K, L, F, G, M, I, J are external
nodes, or leaves A, B, C, D, E,
H are internal nodes
• The level of E is 3
• The height (depth) of the tree
is 4 The degree of node B is 2
• The degree of the tree is 3
• The ancestors of node M is A,
D, H The descendants of
node D is H, I, J, M
Representation of Trees
• There are several ways to represent a given
tree such as:
1. List Representation
2. Left Child- Right Sibling Representation
3. Representation as a Degree-Two tree
 Figure (A).
List Representation:
• The tree can be represented as a List. The tree
of figure (A) could be written as the list.
(A (B (E (K, L), F), C (G), D (H (M), I, J) ) )
• The information in the root node comes first.
• The root node is followed by a list of the
subtrees of that node.
Left Child-Right Sibling Representation
• The below figure show the node structure used in the left
child-right sibling representation
• To convert the tree of Figure (A) into this representation:
1. First note that every node has at most one leftmost child
2. At most one closest right sibling.
Ex:
• In Figure (A), the leftmost child of A is B, and the leftmost child of D is H.
• The closest right sibling of B is C, and the closest right sibling of H is I.
• Choose the nodes based on how the tree is drawn. The left child field of
each node points to its leftmost child (if any), and the right sibling field
points to its closest right sibling (if any).

Figure (D). Left Child- Right sibling representation

Representation as a Degree-Two Tree
• To obtain the degree-two tree representation of a tree, simply
rotate the right-sibling pointers in a left child-right sibling tree
clockwise by 45 degrees. This gives us the degree-two tree
displayed in Figure (E).

Figure (E).
BINARY TREES

Definition:
• A binary tree T is defined as a finite set of nodes such that,
• T is empty or
• T consists of a root and two disjoint binary trees called the left
subtree and the right subtree.
 Different kinds of Binary Tree
1. Skewed Tree
• A skewed tree is a tree, skewed to the left or skews to the right.
or
• It is a tree consisting of only left subtree or only right subtree.
• A tree with only left subtrees is called Left Skewed Binary Tree.
• A tree with only right subtrees is called Right Skewed Binary Tree
2. Complete Binary Tree
• A binary tree T is said to complete if all its levels, except possibly
the last level, have the maximum number node 2i, i ≥ 0 and if all
the nodes at the last level appears as far left as possible.
3. Full Binary Tree
• A full binary tree of depth ‘k’ is a binary tree of depth k
having 2k – 1 nodes, k ≥ 1.

Figure: Full binary tree of level 4 with sequential node number

4. Extended Binary Trees or 2-trees
• An extended binary tree is a transformation of any binary tree into a
complete binary tree. This transformation consists of replacing
every null subtree of the original tree with “special nodes.” The
nodes from the original tree are then internal nodes, while the
special nodes are external nodes.
 PROPERTIES OF BINARY TREES

Lemma 1: [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.
Proof:
(1) The proof is by induction on i.
Induction Base: The root is the only node on level i = 1.
Hence, the maximum number of nodes on level i =1 is 2i-1
= 20 = 1.
 Induction Hypothesis: Let i be an arbitrary positive integer
greater than 1. Assume that the maximum number of
nodes on level i -1is 2i-2
Induction Step: The maximum number of nodes on level i -
1 is 2i-2 by the induction hypothesis. Since each node in a
binary tree has a maximum degree of 2, the maximum
number of nodes on level i is two times the maximum
number of nodes on level i-1, or 2i-1

(2) The maximum number of nodes in a binary tree of depth k

is k
 Lemma 2: [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
the number of nodes of degree 2, then n0 = n2 + 1.

Proof: Let n1 be the number of nodes of degree one and n the total number
of nodes.
• Since all nodes in T are at most of degree two, we have
n = n0 + n1+ n2------------eqn (1)
• Count the number of branches in a binary tree. If B is the number of
branches, then n =B + 1.
• All branches stem from a node of degree one or two. Thus,
B =n 1+ 2n2.
• Hence, we obtain
n = B + 1= n 1+ 2n2 + 1 ------------eqn (2)
• Subtracting Eqn. (2) from Eqn. (1) and rearranging terms, we get
n0 = n2 +1
• Consider the figure:
• Here, For Figure (b) n2=4, n0= n2+1= 4+1=5
Therefore, the total number of leaf node=5
Lemma 5.4
• If a complete binary tree with n nodes in given, then
for any node with index i, 1 ≦ i ≦ n,
1) Parent(i) is at if i > 1. If i=1, node i is the root.
2) LeftChild(i) is at 2i if 2i ≦ n. If 2i > n, node i has no left
child.
3) RightChild(i) is at 2i+1 if 2i+1 ≦ n. If 2i+1 > n, node i
has no right child.
 BINARY TREE REPRESENTATION

• The storage representation of binary trees can be classified as

1. Array representation
2. Linked representation.

Array representation:
• A tree can be represented using an array, which is called
sequential representation.
• The nodes are numbered from 1 to n, and one dimensional
array can be used to store the nodes.
• Position 0 of this array is left empty and the node numbered i is
mapped to position i of the array.
Linked representation:
The problems in array representation are:
1. It is good for complete binary trees, but more
memory is wasted for skewed and many other binary
trees.
2. The insertion and deletion of nodes from the middle
of a tree require the movement of many nodes to
reflect the change in level number of these nodes.
• These problems can be easily overcome by linked
representation
Each node has three fields,
• LeftChild - which contains the address of left subtree
• RightChild - which contains the address of right subtree.
• Data - which contains the actual information

C Code for node:

typedef struct node *treepointer;
typedef struct
{
int data;
treepointer leftChild, rightChild;
}node;
Figure: Node representation
Linked representation of the binary tree
BINARY TREE TRAVERSALS
• Visiting each node in a tree exactly once is
called tree traversal
• The different methods of traversing a binary
tree are:
1. Preorder
2. Inorder
3. Postorder
4. Level-Order traversal
• Inorder: Inorder traversal calls for moving down the tree
toward the left until you cannot go further. Then visit the
node, move one node to the right and continue. If no move
can be done, then go back one more node.

Recursion function:
• The inorder traversal of a binary tree can be recursively
defined as
– Traverse the left subtree in inorder.
– Visit the root.
– Traverse the right subtree in inorder.
void inorder(treepointerptr)
{
if (ptr)
{
inorder (ptr→leftchild);
printf (“%d”,ptr→data);
inorder (ptr→rightchild);
}
}
Preorder: Preorder is the procedure of visiting a node, traverse
left and continue. When you cannot continue, move right and
begin again or move back until you can move right and
resume.

Recursion function:
• The Preorder traversal of a binary tree can be recursively
defined as
– Visit the root
– Traverse the left subtree in preorder.
– Traverse the right subtree in preorder
void preorder (treepointerptr)
{
if (ptr)
{
printf (“%d”,ptr→data) ;
preorder (ptr→leftchild);
preorder (ptr→rightchild);

}
}
Postorder: Postorder traversal calls for moving down the tree
towards the left until you can go no further. Then move to the
right node and then visit the node and continue.

Recursion function:
• The Postorder traversal of a binary tree can be recursively
defined as
– Traverse the left subtree in postorder.
– Traverse the right subtree in postorder.
– Visit the root
void postorder(treepointerptr)
{
if (ptr)
{
postorder (ptr→leftchild);
postorder (ptr→rightchild);
printf (“%d”,ptr→data);
}
}
Level-Order traversal:
• Visiting the nodes using the ordering suggested by the
node numbering is called level ordering traversing.
 THREADED BINARY TREE
• The limitations of binary tree are:
– In binary tree, there are n+1 null links out of 2n total
links.
– Traversing a tree with binary tree is time consuming.
These limitations can be overcome by threaded
binary tree.

• In the linked representation of any binary tree,

there are more null links than actual pointers.
These null links are replaced by the pointers, called
threads, which points to other nodes in the tree.
• To construct the threads use the following rules:
1. Assume that ptr represents a node. If ptr→leftChild is
null, then replace the null link with a pointer to the
inorder predecessor of ptr.
2. If ptr →rightChild is null, replace the null link with a
pointer to the inorder successor of ptr.

Figure A: Binary Tree

Figure B: Threaded tree corresponding to Figure A
• The complete memory representation for the tree of figure
is shown in Figure C
Inorder Traversal of a Threaded Binary Tree
• By using the threads, an inorder traversal can be performed
without making use of a stack.
• For any node, ptr, in a threaded binary tree, if ptr→rightThread
=TRUE, the inorder successor of ptr is ptr →rightChild by
definition of the threads. 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 leftThread = TRUE.
• The function insucc ( ) finds the inorder successor of any node
in a threaded tree without using a stack.
Inserting a Node into a Threaded Binary Tree
• In this case, the insertion of r as the right child of a node s is
studied. The cases for insertion are:
• If s has an empty right subtree, then the insertion is simple and
diagrammed in Figure (a)
• If the right subtree of s is not empty, then this right subtree is
made the right subtree of r after insertion. When this is done, r
becomes the inorder predecessor of a node that has a leftThread
== true field, and consequently there is a thread which has to be
updated to point to r. The node containing this thread was
previously the inorder successor of s.