Sanjivani Rural Education Society’s

Sanjivani College of Engineering, Kopargaon-423 603

(An Autonomous Institute, Affiliated to Savitribai Phule Pune University, Pune)
NACC ‘A’ Grade Accredited, ISO 9001:2015 Certified

Department of Computer Engineering

(NBA Accredited)

Subject- Data Structures-II(CO214)

Unit-I Tree

Prof.B.B.Kotame
 Binary Tree
• In binary tree, every node can have at A

most two branches i.e. there is no

node with degree greater than two. B C

• Definition:

- A binary tree is a finite set of nodes, D F

which is either empty or consist of a

T and two disjoint binary tree called E G

as left sub tree and the right sub tree.

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

- Difference between tree and binary tree

1. For every node may have left sub tree and right sub tree whereas in tree
sub tree doesn’t matter.

2. Binary tree can have zero nodes i.e. binary tree can be empty, which is
not in case of tree
3.
A A In this example 1st binary tree has empty right sub tree
while second binary tree has empty left tree. if we consider
B
B
as tree then both are same only representation is different.

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 Properties of Binary Tree
1. Minimum number of nodes in a binary tree of height H = H + 1
Example-

To construct a binary tree of height = 4, we need at least 4 + 1 = 5 nodes.

2. Maximum number of nodes in a binary tree of height H= 2 H+1 – 1

Example-

Maximum number of nodes in a binary tree of height 3

= 23+1 – 1
= 16 – 1
= 15 nodes

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 3. Total Number of leaf nodes in a Binary Tree
= Total Number of nodes with 2 children + 1
Here, Number of leaf nodes = 3, Number of nodes with 2 children = 2
• Clearly, number of leaf nodes is one greater than number of nodes with
2 children.

4. Maximum number of nodes at any level ‘L’ in a binary tree= 2 L

Example-

Maximum number of nodes at level-2 in a binary tree

= 22
=4
Thus, in a binary tree, maximum number of nodes that can be present at
level-2 = 4.

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

1. The height of a binary tree that contains n, n>=0 element is atmost n and atleast [log 2(n+1)]

example: log2(n+1) if n=15

= log2 (15+1)=log(16)/log(2)

=4 (n<= 2h-1)

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 Exercise
1. A binary tree T has n leaf nodes. The number of nodes of degree-2 in T is ______?

1.Log2n 2.n-1 3.n 4. 2n

2. In a binary tree, the number of internal nodes of degree-1 is 5 and the number of internal nodes of degree-2
is 10. The number of leaf nodes in the binary tree is ______?

1. 10 2.11 3.12 4.15

3. A binary tree T has 20 leaves. The number of nodes in T having 2 children is ______?

1. 20 2.10 3.19 4.15

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 Type of Binary Tree
1. Skewed Binary Tree: a binary tree in which every A A

B B
node is having either only left sub tree or right sub
C C
tree
A
2. Almost Complete Binary Tree: In a complete
binary tree, each non-leaf node compulsory has sub B C
tree. Also, in the last or the lowest level of this
binary tree, every node should possibly reside on the D E F G

left side. Here is the structure of a complete binary

H I J
tree:
DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon
Strictly Binary Tree: if every non-terminal node in a binary tree consist of non-
empty left sub tree and right sub tree then such tree is called as strictly binary tree.

- In other words internal node will have either two children or no child at all.

B C

D E

F G

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

Complete Binary Tree/Perfect Binary Tree:

• -A complete binary tree is a binary tree

that satisfies the following 2 properties-

• Every internal node has exactly 2 children.

• All the leaf nodes are at the same level.

• Complete binary tree is also called

as Perfect binary tree.

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

• Extended Binary Tree:

- Each empty sub tree is replaced by a failure node. A failure node is represented by

- Any binary tree can be converted into a extended binary tree by replacing each
empty sub tree by a failure nodes

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 Representation of Binary Tree
• To represent the binary tree in one dimensional array, we need to numbered the
nodes sequentially level by level(left to right).

• Every empty nodes are also numbered. e.g.

A
A
B C
B C
G D

D E F G D G

7 A B C D E F G 13 A B C - G D - - - - - E F

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

• For complete Binary tree there is no issue, but for skew tree there is a lot of
wastage of space. e.g k depth of skew requires 2k-1 space out of only k get
occupied in array.

• Therefore another way is needed to represent the Binary tree. That is nothing but
linked representation which is an efficient way than array.

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 Binary Tree Node

• The code to write a tree node would be similar to what is given below. It has a data part and references
to its left and right child nodes.

In a tree, all nodes share common construct.

Linked representation of Binary Tree
 Conversion of Tree into Binary Tree
• Children of parents added using leftmost child's right sibling relation.

A
A
B

B C H

K
D F I J
E

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 Examples for Exercise
A
A

D D
B C B C

F H
E G I J E
H
F G K

J
I

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 Binary tree Basic Operations

The basic operations that can be performed on a binary tree data structure, are the
following −
Insert − Inserts an element in a tree/create a tree.
Traversals − Searches an element in a tree.
Preorder Traversal − Traverses a tree in a pre-order manner.
Inorder Traversal − Traverses a tree in an in-order manner.
Postorder Traversal − Traverses a tree in a post-order manner.
Search- Search an element in tree using traversals.
Delete- delete an element from binary tree
 Create/Insert OPERATION
• The very first insertion creates the tree. Afterwards, whenever an element is to be inserted, first locate its
proper location. Start searching from the T node, then search for the empty location in the left subtree
and insert the data. Otherwise, search for the empty location in the right subtree and insert the data.
• Algorithm:
1. Enter key to be inserted. Create node as tempNode for it.
2. Check T is NULL, if yes then make tempNode as T of tree
3. If T is not NULL then
4. Take temporary variable *ptr and set *ptr=T
5. Do
i. Ask user in which direction user wants to insert data(Left or right)
ii. if direction is Left the check following condition
iii. if(ptr->left==NULL) //insert node at left of tree
else
{ {
ptr->left=tempNode; ptr=ptr->right;
}
break; } }
else{ iv. Do step 5 while(ptr!=NULL)
ptr=ptr->left; 5. Repeat steps 1 to 5 until no more data to
insert.
} 6. Stop
else //if user gives right direction
{
if(ptr->right==NULL)
{
ptr->right=tempNode;
break;
}
• Btree.cpp
• Enter the element=4
• Do u want to enter more elements (y/n)y
• Enter the element=12
• in which direction(l/r)l
• Do u want to enter more elements (y/n)y 4
• Enter the element=34
• in which direction(l/r)l 12 1
• in which direction(l/r)?r
• Do u want to enter more elements (y/n)y
22
• Enter the element=1
34 32
• in which direction(l/r)r
• Do u want to enter more elements (y/n)y
• Enter the element=22
• in which direction(l/r)r
• in which direction(l/r)?r
• Do u want to enter more elements (y/n)y
• Enter the element=32
• in which direction(l/r)r
• in which direction(l/r)?l
 Binary Tree Traversal
• Traversal is a process to visit all the nodes of a tree and print their values too. Because, all nodes are
connected via edges (links) we always start from the T (head) node.

• This process could be defined recursively.

• We cannot access a node randomly from a tree. There are three ways which we use to traverse a tree −

• In-order Traversal

• Pre-order Traversal

• Post-order Traversal
 1. In - Order Traversal ( LeftChild - T - RightChild )

Algorithm for inorder traversal

Step 1 : Start from the Left Subtree of T .

Step 2 : Then, visit the T.

Step 3 : Then, go to the Right Subtree.

Step 1 : Inoredr on (B) + A+(Inorder on C)

Step 2 : [B+ inorder on(D) ]+A+ (Inorder on C)
Step 3 : B + inorder on(E) + D + Inorder on( F )+ A +Inorder on (C)
Step 4 : B + E + D + F + A +Inorder on(G)+C+ Inorder on(H)
Step 4 : B + E + D + F + A +G+C+ H

Inorder Traversal : B E D F A G C H
 2. Pre - Order Traversal ( T - LeftChild - RightChild )

Algorithm for preorder traversal

Step 1 : Start from the T and visit the T.

Step 2 : Then, go to the Left Subtree.

Step 3 : Then, go to the Right Subtree.

Step 1 : A + Preorder on (B) + Preorder on(C)

Step 2 : A + [B + Preorder on(D)] +Preorder on (C )
Step 3 : A + [B +[D + Preorder on(E )+Preorder on( F)]] + Preorder on (C )
Step 4: A+ B+ D+ E+ F+ [C+Preorder on(G)+Preorder on(H)]
Step 5: A + B + D+ E+ F + C+ G + H
Preorder Traversal : A B D E F C G H
 3. Post - Order Traversal ( Left-Child – Right-Child - T )

• Algorithm for post-order traversal

Step 1 : Start from the Left Subtree (Last Leaf) and visit it.
Step 2 : Then, go to the Right Subtree.
Step 3 : Then, go to the T.

Step 1 : (Postorder on (B) + Postorder on (C) + ( A)

Step 2 : [Postorder on(D)+ B]+ Postorder on (C) + ( A)
Step 2 : [[Postorder on(E)+Postorder on(F)+D]+ B]+ Postorder on (C) + ( A)
Step 3 : E + F + D + B + [[Postorder on(G)+ Postorder on(H)]+C]+A
Step 3 : E + F + D + B + G + H + C + A
Post-order Traversal : E F D B G H C A
void pre_order_traversal(struct node* T)
{
void post_order_traversal(struct node* T)
if(T != NULL)
{
{
if(T != NULL)
cout<<T->data;
{
pre_order_traversal(T->leftChild);
post_order_traversal(T->leftChild);
pre_order_traversal(T->rightChild);
post_order_traversal(T->rightChild);
}
cout<<T->data;
}
}
void inorder_traversal(struct node* T)
}
{
if(T != NULL)
{
inorder_traversal(T->leftChild);
cout<<T->data;
inorder_traversal(T->rightChild);
}
}
 Construction of Binary Tree from Traversal
Inorder- B I D A C G E H F
Postorder- I D B G C H F E A
 Construction of Binary Tree from Traversal
Preorder- A B C D E F G H I
Inorder- B C A E D G H F I
DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon
 Non-Recursive Preorder
• Algorithm:
1. S is an empty stack used to store NODE pointer
2. NODE *temp
3.push(root)
4. while(stack is not empty)
{
temp=pop();
print temp->data;
if temp has right child then push into stack
if temp has left child then push into stack
}
5.stop
 Example

A Stack
Operations
push(root)
B C
temp=pop() A B C D
temp=
D push(temp->right)
push(temp->left)
while(stack is not empty) A
{
temp=pop();
print temp->data;
if temp has right child then push into stack
if temp has left child then push into stack
}
 A

B C

D F

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

void preorder(Node *root)
{ struct stack
Node *temp=root; {
if(!root) return;
struct node *st[max];
push(root);
int top;
while(!isempty(stack))
{
}s;
temp=pop(stack); s.top=-1;
print temp->data; struct Node
if(temp->right!=NULL) {
{ struct Node*left;
push(temp-right) struct node *right;
if(temp->left!=NULL)
int data;
push(temp->left)
}
} }
 Non Recursive Inorder Traversal
• Algorithm
1. S is an empty stack used to store NODE pointer
2. NODE *ptr=root
3. do A
{
while(temp!=NULL)
{ B C
push temp into stack
move temp to its left
} D

pop temp
display temp->data
move temp to its right
} while(!isempty())
4. Stop
 A

B C

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 do
struct stack
{
{
while(temp!=NULL)
struct node *st[max];
{
int top;
s.push(temp)
}; temp=temp->left;
void preorder(Node *h) }
{ temp=s.pop();
Node *temp=h; print temp->data;
stack s; temp=temp->right;
s.top=-1 }while(!isempty())
 Non Recursive Postorder Traversal
• Algorithm

In this traversal each node is visited twice but we are supposed to dispaly
only once.

- Hence there should be some mechanism to indicate whether the node is being
visited 1st time or 2nd time.

- Display the content of the node only when it is visited for the 2nd time.
• Algorithm:
1. S is an empty stack used to store Node
pointer
2. Node *temp= root
3. do
{ A

while(temp!=NULL)
s.push(temp)
temp=temp->left B C

4. pop from stack and assign to temp

temp=s.pop() struct BTnode
{ D
5. if (temp->flag==1)
char data;
print temp->data BTnode *left;
BTnode *right;
temp=NULL
int flag=0;
6. else }
temp->flag=1
s.push(temp)
temp=temp->right
 A

B C

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon

 Breadth -First Search(BFS)

• inorder,preorder and postorder requires stack for traversal, but there are some
traversal techniques which requires queue e.g. BFS

• This traversal is also called as Level order traversal as it visits nodes in levels

e.g.
10
10 5 20 1 7 15

5 20

1 7 15
• Algorithm
10
1. temp=root
2. q.enqueue(temp)
3. while(!isemptyq()) 5 20

{
temp=dqueue(); 1 7 15
print temp->data;
if(temp->left!=NULL)
q.enqueue(temp->left)
if(temp->right!=NULL)
q.enqueue(temp->right)
}
4. Stop
• BFS is generally used for finding minimum cost edges.

• In peer to peer network, to find all neighbour nodes

• define BTree structure BFS(Node *h)
struct queue {
{ queue que;
Node *temp;
node *Q[max] que.front=que.rear=-1;
int rear,front; temp=h;
}q; enqueue(&que,temp);
while(!isemptyQ(&que)
void enqueue(queue *q, node *t)
{
{ q.Q[++q.rear]=t;} temp=dequeue(&que);
node *dequeue(queue *q) print temp->data;
if(temp->leftchild!=NULL)
{ return(q.Q[++q.front])}
enqueue(&que,temp->leftchild);
int isemptyQ(queue *q) if(temp->rightchild!=NULL)
{ return(q->front==q.rear);} enqueue(&que,temp->rightchild);
} }
 Depth -First Search(DFS)
• Tree is traversed according to its depth and visited node in depthwise.
• DFS is a preorder traversal
• start from root node,move along the edge towards left node

10

5 20 10 5 1 7 20 15

1 7 15
• Algorithm

1. Visit the root node. push it into stack

2. Pop the node and display data.

3. if right child is not NULL,push it into stack

4. if left child is not NULL,push it into stack

5. repeat step 2-4 until stack is empty Applications:

1. Topological sorting-> for scheduling jobs
from given dependencies among jobs
2. Path finding: use stack to keep track of
the path between source vertex to
destination vertex
 DESCRIPTION Stack OUTPUT

A
10 visit A and push(A) A
pop and display -1 A
push D BD A
5B D push B
pop B D AB
display B
C E F
push C pop C and D ABC
display
pop D E F A BC D
display D &push E,F
pop E,display E -1 ABCDEF
pop F, display F
 Binary Search Tree
• When we store order data into array structure we use efficient search algorithm.e.g. Binary Search

• However, to provide efficient insertion and deletion operation,we represent a link list.

• The problem with linked list is that their search algo. which are sequential searches,very
ineffecient.

• So what we need is data structure that has efficient search algo. and at the same time efficient
insertion and deletion operation.

• Binary Search Tree provide that structure.

 Cont...

Defination: A Binary search tree is a binary tree with following properties: Key

1. All keys are distincts.

2. All items in the right subtree are greater than equal to the root. all <
Key
all <=
Key

3. each subtree is itself a binary search tree.

17
10
17 17 10
17

58 20
6 19 6 58 20 22 19

11 15 12
19 5 9 25
 Binary Search Tree(BST)
• A binary search tree (BST) is a binary tree that is either empty or in
which every node contains a key (value) and satisfies the following
conditions:
• All keys in the left sub-tree of the root are smaller than the key in the
root
node
• All keys in the right sub-tree of the root are greater than the key in the root
node
• The left and right sub-trees of the root are again binary search trees
Ashim Lamichhane
Binary Search Tree(BST)
• A binary search tree is basically a binary tree, and therefore it can
be traversed in inorder, preorder and postorder.

• If we traverse a binary search tree in inorder and print the identifiers

contained in the nodes of the tree, we get a sorted list of
identifiers in ascending order.

Ashim Lamichhane
Binary Search Tree(BST)

Time Complexity
Array Linked List BST
Search O(n) O(n) O(logn)
Insert O(1) O(1) O(logn)
Remove O(n) O(n) O(logn)

Ashim Lamichhane
 A

B E
Correct A
tree D C F
B E
I G
H
D G F

A
I C
H
B E

C G F

D I
H

DEPARTMENT OF COMPUTER ENGINEERING, Sanjivani COE, Kopargaon