UNIT IV

Binary Trees: Introduction to Non- Linear Data Structures, introduction Binary Trees, Types of Trees, Basic
Definition of Binary Trees, Properties of Binary Trees, Representation of Binary Trees, Operations on a
Binary Search Tree, Binary Tree Traversal, Counting Number ofBinary Trees, Applications of Binary Tree.

TREE
A tree is a non-linear data structure and is generally defined as a nonempty finite set of
elements, called nodes such that:
1. It contains a special node called root of the tree.
2. Others all nodes are partitioned under root, and should exist one path between any pairs
of nodes. (It doesn’t form any cycle).

Tree Terminologies:
In a tree data structure, we use the following terminology...

1. Root:
In a tree data structure, the first node is called as Root Node. Every tree must have root
node. We can say that root node is the origin of tree data structure. In any tree, there
must be only one root node. We never have multiple root nodes in a tree.

2. Edge:
In a tree data structure, the connecting link between any two nodes is called as
EDGE. In a tree with 'N' number of nodes there will be a maximum of 'N-1' number of
edges.

1
3. Parent:
In a tree data structure, the node which is predecessor of any node is called as
PARENT NODE. In simple words, the node which has branch from it to any other node is
called as parent node. Parent node can also be defined as "The node which has child /
children".

4. Child:
In a tree data structure, the node which is descendant of any node is called as
CHILD Node. In simple words, the node which has a link from its parent node is called as
child node. In a tree, any parent node can have any number of child nodes. In a tree, all
the nodes except root are child nodes.

5. Siblings:
In a tree data structure, nodes which belong to same Parent are called as
SIBLINGS. In simple words, the nodes with same parent are called as Sibling nodes.

2
6. Leaf:
In a tree data structure, the node which does not have a child is called as LEAFNode. In
simple words, a leaf is a node with no child.
In a tree data structure, the leaf nodes are also called as External Nodes.
External node is also a node with no child. In a tree, leaf node is also called as 'Terminal'
node.

7. Internal Nodes:
In a tree data structure, the node which has atleast one child is called as INTERNAL
Node. In simple words, an internal node is a node with atleast one child. In a tree
data structure, nodes other than leaf nodes are called as Internal Nodes. The root node
is also said to be Internal Node, if the tree has more than one node. Internal nodes are
also called as 'Non-Terminal' nodes.

8. Degree:
In a tree data structure, the total number of children of a node is called as
DEGREE of that Node. In simple words, the Degree of a node is total number of children
it has. The highest degree of a node among all the nodes in a tree is called as 'Degree of
Tree'

9. Level:
In a tree data structure, the root node is said to be at Level 0 and the children of root
node are at Level 1 and the children of the nodes which are at Level 1 will be at Level 2
and so on... In simple words, in a tree each step from top to bottom is called as a Level
3
 and the Level count starts with '0' and incremented by one at each level (Step).

10. Height:
In a tree data structure, the total number of edges from leaf node to a particular node in
the longest path is called as HEIGHT of that Node. In a tree, height of the root node is
said to be height of the tree. In a tree, height of all leaf nodes is '0'.

11. Depth:
In a tree data structure, the total number of egdes from root node to a particular node is
called as DEPTH of that Node. In a tree, the total number of edges from root node to a
leaf node in the longest path is said to be Depth of the tree. In simple words, the highest
depth of any leaf node in a tree is said to be depth of that tree. In a tree, depth of the
root node is '0'.

12. Path:
In a tree data structure, the sequence of Nodes and Edges from one node to another
node is called as PATH between that two Nodes. Length of a Path is total number of
nodes in that path. In below example the path A - B - E - J has length 4.
 13. Sub Tree:
In a tree data structure, each child from a node forms a subtree recursively.Every child
node will form a subtree on its parent node.

BINARY TREE
A binary tree is defined as a finite set of elements, called nodes, such that:
1 Tree is empty (called the null tree or empty tree) or
2 Tree contains a distinguished node called root node, and the remaining nodes
form anordered pair of disjoint nodes less than two only.
3 A tree T is said to be binary tree if there exists exactly 0,1,2 children nodes for
each node of the tree i.e.,the number of children of a node is at most 2.
In the above tree-
“A” is the root node and
“B” and “C” are called subtrees.
B and C are left and right successor of A.
The node A is called parent node
B and C are called children.
All lower level nodes are called descendants
All upper level nodes are called ancestors of their descendants.
The line drawn between parent and child is called an edge
the line(s) between and ancestor and descendant is called path.
A node without any children is called a terminal or leaf node
A path ending with a leaf is called a branch.

Properties of binary trees

• The depth of a binary tree containing N nodes is at most N-1.
• The depth of a binary tree containing N leaves is at least [log2(N)].
• A binary tree of depth d has at most 2d leaves.
• The number of nodes in a binary tree of depth d is at most 2d-1 - 1.

• The average depth of a binary tree containing N nodes is () Ο Ν .

• The maximum number of nodes on level i of a binary tree is 2i-1, i  1
• The maximum number of nodes in a binary tree of depth k is 2k – 1, k  1
• If a complete binary tree with n nodes (depth =  log2n +1  ) 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. left_child( i ) is at 2i if 2i  n. If 2i > n, then i has no left child
3. rightt_child( i ) is at 2i + 1 if 2i + 1  n. If 2i + 1 > n, then i has no right child

TYPES OF TREES

1. Complete Binary Tree:

A binary tree is said to be complete if all its level except possibly the
last, have maximum number of possible nodes, and if all the nodes
at the last level appear as far left as possible.

2. Full binary tree:

A binary tree said to be full if all its level have maximum number of
possible node.

3. Extended Binary Tree (Strictly Binary Tree or 2-tree):

A binary tree is said to be Extended binary tree if each node has either 0 or 2 children. In
this case the leaf nodes are called external nodes and the node with two children are
 called internal nodes.

4. Skewed Tree:
A tree is called Skew if all the nodes of a tree are attached to one
side only. i.e A left skew will not have any right children in its each
node and right skew will not have any left child in its each node.

APPLICATIONS OF BINARY TREES

• Binary Search Tree

Used in many search applications where data is constantly entering/leaving, such as
the map and set objects in many languages' libraries.
• Binary Space Partition
Used in almost every 3D video game to determine what objects need to be rendered.
• Binary Tries
Used in almost every high-bandwidth router for storing router-tables.
• Hash Trees
Used in p2p programs and specialized image-signatures in which a hash needs to be
verified, but the whole file is not available.
• Heaps
Used in implementing efficient priority-queues, which in turn are used for scheduling
processes in many operating systems, also used in heap-sort.
• Huffman Coding Tree (Chip Uni)
Used in compression algorithms, such as those used by the .jpeg and .mp3 file-formats.
• GGM Trees
Used in cryptographic applications to generate a tree of pseudo-random numbers.
BINARY-TREE REPRESENTATION
A binary tree data structure is represented in two ways.
A. Array representation
B. Linked list representation
A. ARRAY REPRESENTATION:
In array representation of binary tree, we use one-dimensional array. Let’s consider
the following tree.

1. Store the left child at 2*i+1 position, if its parent node is at ith position.
2. Store the right child at 2*i+2 position, if its parent node is at ith position.
3. We need one-dimensional array with a maximum size of 2n+1-1, to represent a binary
tree of depth “n”.
4. The above example is represented as follows.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

A B C D E F G H I - - - J - - -

Advantages:
• This method benefits from more compact storage and better locality of reference,
particularly during a preorder traversal.
Limitations:
• Wastage of space for some types of binary tree.
• Insertion and deletions require potential changes in the array.

B. LINKED REPRESENTATION:
We use double linked list to represent binary tree. In a double linked list, every node
consists of three fields. First field is used to store the left child address, second field is
used to store data, third field is used to store right child address.

Advantages:
• Insertion and deletion involve no data movement and no movement of nodes
except the rearrangement of pointers.
Limitations:
• Given a node structure, it is difficult to determine its parent node.
• Memory spaces are wasted for storing NULL pointers for the nodes, which have
no subtrees.
BINARY TREE TRAVERSAL
There are three different types of traversing techniques to traverse a binary tree.
Traversing means visiting each and every node of a tree. The following are the different
traversing techniques.
1. Pre-order traversal
2. In-order traversal
3. Post-order traversal
1. Pre-Order Traversal:
In this traversing technique, the root of the tree is visited first and followed by left sub-
tree and then right sub-tree is visited. The following is the sequence of visiting order of
pre-order traversal.

Left Right
Roo
sub- sub-
t
tree tree
Algorithm for Pre-Order Traversal: void preorder(node root)
Step-1: (check if the tree is empty by { if( root != NULL )
verifying root pointer) { print root . data;
If (p==NULL) preorder (root . lchild);
Print tree is empty preorder (root . rchild);
}
Step-2: visit root (root.data)
}
Step-3: visit left sub-tree (root.lchild)
Step-4: visit right sub-tree (root.rchild)
Step-5: exit.
Implementation:

The pre-order traversal of the above tree is as follows:

A→B→C→H→D→E→F→G→I→J
2. In-Order Traversal
In this traversing technique the left sub-tree visited first followed by its root and then the
right sub-tree is visited. The following is the sequence of visiting order for an in-order
traversal.
Left Right
Roo
sub- t sub-
tree tree
 Algorithm for In-Order Traversal:
Step-1: (check if the tree is empty by
verifying root pointer) void inorder(node root)
{ if(root != NULL)
If (p==NULL) {
Print tree is empty inorder(root . lchild);
Step-2: visit left sub-tree (root.lchild) print root . data;
Step-3: visit root (root.data) inorder(root . rchild);
Step-4: visit right sub-tree (root.rchild) }
Step-5: exit }

Implementation:

The In-Order traversal of the above tree is as follows:

H→C→B→D→A→F→E→G→I→J
3. Post-Order Traversal:
In this traversing technique, the left sub-tree is visited first and then right sub-tree is
visited and then root is visited. The following is the sequence of visiting order of post
order.
Left Right
Roo
sub- sub- t
tree tree
Algorithm for Post-Order Traversal:
Step-1: (check if the tree is empty by verifying void postorder(node root)
root pointer) { if( root != NULL )
If (p==NULL) { preorder (root . lchild);
preorder (root . rchild);
Print tree is empty print root . data;
Step-2: visit left sub-tree (root.lchild) }
Step-3: visit right sub-tree (root.rchild) }
Step-4: visit root (root.data)
Step-5: exit
Implementation:
 The post-order traversal of the above tree is as follows:
H→C→D→B→F→J→I→G→E→A
Another traversal method
LEVEL ORDER TRAVERSAL:
In a level order traversal, the nodes are visited level by level starting from the root, and going
from left to right. The level order traversal requires a queue data structure. So, it is not
possible to develop a recursive procedure to traverse the binary tree in level order. This is
nothing but a breadth first search technique. The algorithm for level order traversal is as follows:
void levelorder( )
{ int j;
for(j = 0; j < ctr; j++)
{
if(tree[j] != NULL)
print tree[j] . data;
}
}

Examples of Tree traversals

+ *

g Preorder ++a*bc*+*defg
a * + Inorder a+b*c+d*e+f*g
Postorder abc*+de*f+g*+

b c * f

d e
BINARY SEARCH TREE (BST)
First of all, binary search tree (BST) is a dynamic data structure, which means, that its size is
only limited by amount of free memory in the operating system and number of elements may
vary during the program run.
A Binary tree is said to be binary search tree if the nodes of the left sub-
tree of the root node are less than root node and the nodes of the right sub-tree of the
root node are greater than or equal to the root node.
Binary search tree is a data structure, which meets the following requirements:

• It is a binary tree;
• Each node contains a value/key;
• Every element has a value and no two elements have the same value
• The keys in the left subtree are smaller than the key in the root.
• The keys in the right subtree are larger than the key in the root.
• Notice, that definition above doesn't allow duplicates.

Let us consider the following numbers to be stored into a binary search tree.
35, 14, 10, 25, 40, 50, 45, 65
The binary search tree of above data is as follows:

TRAVERSAL OF BST
The following are the different traversing techniques.
1. Pre-order traversal
2. In-order traversal
3. Post-order traversal
1. Pre order traversal
Algorithm for Pre-Order traversal:
Step-1: visit root node (display root.data) Step-
2: visit left sub-tree preorder(root.lchild) Step-
3: visit right sub-tree preorder(root.rchild)
Pre-Order : 35 → 14 → 10 → 25 → 40 → 50 → 45 → 65

2. In order traversal
Algorithm for In-order traversal:
Step-1: visit left sub-tree inorder(root.lchild)
Step-2: visit root node ( display root.data)
Step-3: visit right sub-tree inorder(root.rchild)
In-Order : 10 → 14 → 25 → 35 → 40 → 45 → 50 → 65
 3. Post order traversal
Algorithm for Post-Order traversal:
Step-1: visit left sub-tree postorder(root.lchild)
Step-2: visit right sub-tree postorder(root.rchild)
Step-3: visit root node (display root.data)

Post-Order : 10 → 25 → 14 → 45 → 65 → 50 → 40 → 35

OPERATIONS ON BST
In order of this binary search tree gives ascending order of the list. Operations that can be performed
on binary search tree are:
1) Searching
2) Inserting any data
3) Deleting any data from BST

1. Searching in the binary search tree:-

Searching in BST is much faster than arrays or linked list. Suppose we have to search for “ITEM”
in a binary search tree “T”. We start from root node “ROOT”. If “ITEM” is less than value in
“ROOT”, we proceed to left child. If ITEM is greater than value in ROOT, we proceed to right child.
We continue searching until we have found the desired value or reach the end of the tree.
Algorithm:
1. Read the search value
ITEM = Get value ( )
2. Initializing the variable “p” to root.
P = ROOT
3. Initialize the flag variable
flag = false;
4. Start the search process
while (p!=NULL && flag= = FALSE)
5. Check the ITEM and goto the left subtree
if (ITEM<data(p)) then p=left child(p);
6. Check the ITEM and goto right sub tree.
if (ITEM>data(p)) then p= right child (p);
7. Check the ITEM, if the ITEM is found.
If (ITEM = = data (p) then
8. Change the flag status
flag = TRUE;
End if
End while
9. Check the flag status
if (flag = = TRUE) then
print “Data item found at “, p
else
print “search unsuccess”
end if
10. Finish
STOP
2. Inserting in to binary search tree:-
This is very simple and is extension of searching in binary search tree. To insert “ITEM” in to binary
search tree “T”. We start searching in “T” for “ITEM” from the root node. If “ITEM” is found in binary
search tree there is no insertion. If “ITEM” is not found then we insert it at the dead-end where the
search stops.
Algorithm:-
1. Access root node
P=ROOT;
2. Read the data ITEM
ITEM=Get value ( );
3. Search for correct dead-end node
while (p!=NULL) {
4. If the ITEM is less than node data, then move to left child
if (ITEM < Data(p))
p=Left child (p);
5. If the ITEM is greater than node data, then move to right child
else if(ITEM > Data(p))
p=Right child (p);
6. If the data ITEM is available in BST then STOP the process.
else if (ITEM = = Data(p))
{
print “The node already exist”;
EXIT;
}
} // End while
7. Insert new node at END. If ITEM is less than node data then create left child.
if (ITEM < Data(p))
Left child (p) = ITEM;
8. Otherwise the ITEM stores as a right child of the node.
else if (ITEM > Data(p))
Right child (p) = ITEM;
9. Finish
STOP

3. Deleting a node from binary search tree:-

Another important function for maintaining BST is to delete a specific node form the tree. The
method to delete a node depends on the specific position of the node in the tree. The algorithm to
delete a node can be subdivided in to 3 cases.

Case (i):
If the node to be deleted is a leaf, we only need to set the appropriate link of its parent to NULL
and dispose of the node which is deleted.
Ex:
10
0

50
15
0
To delete 50 from the BST
 10
0

NULL
150
Case (ii):
If the node to be deleted has only one child, we can not simply make the link of the parent to
NULL. We need to adjust the link from the parent of the deleted node to point to the child of the
delete node, then dispose of the deleted node.
Ex:
10
0

15
0

20
0
To delete 15 from the BST.
0
After dispose 150, the result BST is:

10
0

20
Case (iii): 0
The most complicated problem comes when we have to delete a node with two children. There
is no way we can make the parent of the delete node to point to both of the children of the
deleted node.
Ex:
35

20 45

16 29

24 33

27
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 If we want to delete 20 , first we have to delete 20
and replace the node with 29

35

29 45

16 33

24

AVL Trees
A binary search tree can be maintained equal sized left and right sub trees, it is correctly suitable to
efficient searching operation. Such a binary search tree is called as balanced binary tree or AVL tree. It
was developed in the year 1962 by Adelson, Velskii and Landis.

Threaded Binary Tree (TBT):

We know that a binary tree is represented either by using arrays or by using linked list.
1. When a binary tree is represented is by using linked list, if any node is not having
a child, we use null reference in that position.
2. In any binary tree there are more number of null references than actual
references, it wastes lot of storage space.

To convert a binary tree into threaded binary tree

1. Keep the null values as it is in the left-child reference of left most node and right-
child of right most node.
2. Write the in-order traversal of binary tree.
3. If the null reference is from left child then point it to its in-order predecessor and
and point in-order successor in case of right child.

Consider the above binary tree. We need to keep null values in left-child reference of left
most node and right-child reference of right most node.

16
Now the in-order traversal of the above tree is
D→B→E→A→C→F
Now remove null values and replace them with in-order predecessor in case of left-
child and with in-order successor in case of right-child.

The problem with above representation is that we can‟t find the direct child and parent
node references. In-order to achieve this we need to rearrange the node structure as
follows:

Field-1 - reference of left child

Field-2 - left flag i.e., 0 or 1
Field-3 - data in that node
Field-4 - right flag i.e., 0 or 1
Field-5 - reference of right child

➔ In fileds2 and 4 the value 0 represents left/right child references to its parent/ancestor
node.
➔ In fields2 and 4 the value 1 represents left/right child references to its direct child
node.
And we create a temporary node which does not contain any data and it is referenced by
left-child of left most node and right-child of right most child. The left child reference of
temporary node points to root node and the right child references to itself.

17
Heap Tree:
Heap data structure is a specialized binary tree based data structure. Hence it is a binary
tree with special characteristics. In a heap data structure, nodes are arranged based on their
values.
Every Heap data structure has the following properties.
1. ORDERING: Nodes must be arranged in a order according to values based on max
heap or min heap.
2. STRUCTURAL: All levels in a heap must be full, except last level and nodes must be
filled from left to right strictly.
A binary heap is a complete binary tree which satisfies the heap ordering property.
The ordering can be one of two types:
 Min-heap
The value of each node is greater than or equal to the value of its parent, with the
minimum-value element at the root.
2. Max-heap
The value of each node is less than or equal to the value of its parent, with the maximum-
value element at the root.

MAX-HEAP:
Max-Heap is a specialized full binary tree in which every parent node contains greater
value or equal value than its child nodes. In Max heap, the value of the root node is greater
than or equal to either of its children.

Above tree is satisfying both ordering property and structural property according to the

18
Max-Heap data structure.
The following operations are performed in Max-Heap data structure:
1. Finding maximum
2. Insertion
3. Deletion
Insertion operation in Max-Heap:
Step-1: Insert the new node as last leaf
from left to right Step-2: Compare new
node with its parent node.
Step-3: If new node value is greater than its parent node value then swap both values.
Step-4: repeat step-2 and step-3 until new node value is less than its parent node or new
node reached root.

MIN-HEAP:
Min-Heap tree is a specialized full binary tree in which every parent node contains less
value or equal value than its child nodes. In Min-Heap tree, value of the root node is less
than or equal to either of its children.

The following operations are performed on Min-Heap data structure.

1. Finding the minimum
2. Insertion
3. Deletion
Insertion operation in Min-Heap:
Step-1: Insert the new node as last leaf from left to right
Step-2: Compare new node with its parent node.
Step-3: If new node value is less than its parent node value then swap both values.
Step-4: repeat step-2 and step-3 until new node value is greater than its parent node or new
node reached root.

19
Lab programs

Binary Tree and its traversals

#include<stdlib.h>
#include<stdio.h>
struct bin_tree
{
int data;
struct bin_tree * right, * left;
};
typedef struct bin_tree node;
void insert(node ** tree, int val)
{
node *temp = NULL;
if(!(*tree))
{
temp = (node *)malloc(sizeof(node));
temp->left = temp->right = NULL;
temp->data = val;
*tree = temp;
return;
}
if(val < (*tree)->data)
{
insert(&(*tree)->left, val);
}
else if(val > (*tree)->data)
{
insert(&(*tree)->right, val);
}
}
void print_preorder(node * tree)
{
if (tree)
{
printf("%d\n",tree->data);
print_preorder(tree->left);
print_preorder(tree->right);
}
}
void print_inorder(node * tree)
{
if (tree)
{
print_inorder(tree->left);
printf("%d\n",tree->data);
print_inorder(tree->right);
}
}
void print_postorder(node * tree)
{
if (tree)
{
20
 print_postorder(tree->left);
print_postorder(tree->right);
printf("%d\n",tree->data);
}
}
void deltree(node * tree)
{
if (tree)
{
deltree(tree->left);
deltree(tree->right);
free(tree);
}
}
node* search(node ** tree, int val)
{
if(!(*tree))
{
return NULL;
}
if(val < (*tree)->data)
{
search(&((*tree)->left), val);
}
else if(val > (*tree)->data)
{
search(&((*tree)->right), val);
}
else if(val == (*tree)->data)
{
return *tree;
}
}
void main()
{
node *root;
node *tmp;
//int i;

root = NULL;
/* Inserting nodes into tree */
insert(&root, 9);
insert(&root, 4);
insert(&root, 15);
insert(&root, 6);
insert(&root, 12);
insert(&root, 17);
insert(&root, 2);

/* Printing nodes of tree */

printf("Pre Order Display\n");
print_preorder(root);

printf("In Order Display\n");

21
 print_inorder(root);

printf("Post Order Display\n");

print_postorder(root);

/* Search node into tree */

tmp = search(&root, 4);
if (tmp)
{
printf("Searched node=%d\n", tmp->data);
}
else
{
printf("Data Not found in tree.\n");
}

/* Deleting all nodes of tree */

deltree(root);
}

Output

display binary tree in pre-order, in-order and post-order forms.

Pre Order Display

9
4
2
6
15
12
17
In Order Display
2
4
6
9
12
15
17
Post Order Display
2
6
4
12
17
15
9
Searched node=4

22