Unit 3 and 4

Unit 3
Linear Data Structures- Doubly Linked List
Doubly Linked list:
Double linked list is a sequence of elements in which every element has links to its previous
element and next element in the sequence. A doubly linked list is a linear collection of nodes
where each node is divided into 3 parts:
a) info – This is a field where the information has to be stored.
b) llink – This is a pointer field which contains address of the left node or previous node in the
last
c) rlink – This is a pointer field which contains address of the first node or next node in the list.
Pictorial representation of doubly linked list:
Using this list, it is possible to traverse the list in forward and backward directions. Such a list
where each node has 2 links is also called a two-way list.
Operations on Double Linked List:
Insertion:
Inserting a node at the front end:
Step 1: Create a node:
This can be done using getnode() function and copying item 5 as:
temp=getnode ();
tempinfo=item;
templink=temprlink=NULL;
Step 2: Insert into empty list:
If the list is empty, the above created node itself should be returned as the first node. The
code can be written as:
if(first==NULL) return temp;
Step 2: Inserting into existing list:
Now I will consider the following list to see how a node temp can be inserted at the front end:
To insert temp at the front end of the list, copy first into rlink of temp and copy temp into
llink of first node using this code:
temprlink=first;
firstllink=temp;
Step 3: Return the first node:
After modification, always we have to return the address of the first node. In the above list,
temp is the first node and it can be returned using the statement:
return temp;
C function to insert an item at the front end of the list:
NODE insert_front(int item, NODE first)
NODE temp;
temp=getnode (); //obtain a node from OS
tempinfo=item; //insert an item into new node
if(first==NULL) return temp; //insert a node for the first time
temprlink=first; //insert at the beginning of existing list
firstllink=temp;
return temp; //return address of new first node
Inserting a node at the rear end
Step 1: Create a node:
This can be done using getnode() function and copying item 50 as:
temp=getnode ();
tempinfo=item;
Step 2: Insert into empty list:

If the list is empty, the above created node itself should be returned as the first node. The
code can be written as:
Step 2: Find the address of last node:
Consider the following list and see how node temp can be inserted at rear end:
Let the variable first always contain address of the first node. Let me use another variable
current pointing to first node. This can be done as:
cur=first;
Now, the pictorial representation of linked list is:
Now keep updating current to point to the next node as long as rlink field of current is not
NULL. This can be written as:
while(currlink!=NULL)
cur=currlink;
Now after executing the above while loop, the variable cur contains address of the last node
of the list as:
Step 3: Insert node at the end:
rlink of cur should contain address of temp. This can be done as:
currlink=temp;
llink of temp should contain address of cur. This can be done as:
templlink=cur;
After executing the above 2 statement as:
Step 4: Return address of first node:
This can be done using statement as:
return first;
C function to insert an item at the rear end of the list:
NODE insert_front(int item, NODE first)
NODE temp;
temp=getnode (); //obtain a node from OS
tempinfo=item; //insert an item into new node
if(first==NULL) return temp; //insert a node for the first time
cur=first; //get the address of first node
while(currlink!=NULL) //find address of last node
cur=currlink;
currlink=temp; //insert the node at the end
templlink=cur;
return first; //return address of the first node
Deletion:
Deleting a node from the front end of the list:
Step 1: List is empty:
If the list is empty, it is not possible to delete a node from the list. In such case, we have to
display the message “list is empty” and return NULL. The code can be written as:
if(first==NULL)
printf((“list is empty\n”);
return NULL;
Step 2: Delete if there is only one node:
A list having one node can be written as:
if(firstrlink==NULL)
{
printf(“item deleted=%d\n”,firstinfo);
free(first);
return NULL;
When control comes out of the above if statement, it means that the list has more than one
node and the list can be pictorially represented as:
Step 3: Obtain the address of the second node:
The address of second node can be obtained using the statement as:
second=firstrlink;
Step 4: Make second node as first node:
It is achieved by copying NULL to left link of second node. It can be written as:
secondllink=NULL;
Now first node is isolated and the linked list can be shown as:
Step 5: Delete the front node:
It is achieved using free() function. The code can be written as:
free(first);
After executing the code, list can be pictorially represented as:
Step 6: Return address of the new first node:
Now the variable second contains address of new first node and it can be returned using the
statement:
return second;
C function to delete an item from the front end of the list:
NODE delete_front(NODE first)
NODE second;
if(first==NULL) //check for empty list
printf(“List is empty cannot deleted\n”);

return NULL; //we can replace NULL with first also
if(firstrlink==NULL) //delete if there is only one node
free(first);
return NULL;
second=firstrlink; //get the address of second node
secondllink=NULL; //make second node as first node
free(first); //delete the first node
return second;
Deleting a node from rear end:
Step 1: List is empty:
If the list is empty, it is not possible to delete a node from the list. In such case, we have to
display the message “list is empty” and return NULL. The code can be written as:
if(first==NULL)
return NULL;
}
Step 2: Delete if there is only one node:
A list having one node can be written as:
if(firstrlink==NULL)
free(first);
return NULL;
When control comes out of the above if statement, it means that the list has more than one
To delete last node, we should know the address of the last node and last but one node. We
will see this in the coming steps
Step 3: Obtain the address of the first node and its predecessor:
This can be done using two pointer variable: cur and prev. Initially, cur points to the first
node and previous points to \0(NULL). This can be achieved using statement:
prev=NULL;
cur=first;
Step 4: Find the address of last node and last but one node:
This can be done by updating current and previous till current contains address of the last
node and previous contains address of the last but one node. This can be achieved by using:
while(curlink!=NULL)
prev=cur;
cur=curlink;
After executing the above loop the variable current contains address of the last node and
previous contains address of last but one node as:
Step 5:
The last node pointed to by current can be deleted as:
printf(“item deleted=%d\n”,curinfo); //item deleted=40
free(cur);
Step 4:
Once the last node is deleted, the node pointed to by prev should be the last node. This can be
achieved by copying NULL to rlink field of prev as:
The code can be written as:
prevrlink=NULL; //node pointed to by prev is the last node
Step 5:
Finally return address of the first node
C function to delete an item from rear end of the list:
NODE delete_rear(NODE first)
NODE cur, prev;
return NULL;
if(firstlink==NULL) //only one node is present and delete it
free(first); //return to availability list

return NULL; //list is empty so return NULL
//obtain the address of last node and just previous to that
prev=NULL;
cur=first;
while(curlink!=NULL)
prev=cur;
cur=curlink;
printf(“item deleted=%d\n”,curinfo); //item deleted=40
free(cur); //delete a last node
prevrlink=NULL; //node pointed to by prev is the last node
Display doubly linked list:
The function that is used to display normal linked list can be used to display the contents of
doubly linked list. Only change is that link field should be replaced by rlink. The C function
is:
void display(NODE first)
NODE cur;
int count=0;
return;
printf(“the contents of singly linked list\n”);

cur=first; //holds address of first node
while(cur!=NULL) //as long as no end of list
printf(“%d”,curinfo);
count++;
cur=currlink; //point to next node
printf(“number of nodes=%d\n”,count);
Circular doubly linked list:
We have seen that the left link of the leftmost node and right link of rightmost node points to
NULL.
The 2 variation of doubly linked list are:
a) circular doubly linked list
b) circular doubly linked list with a header node
A circular linked list is a variation of doubly linked list in which every node in the list has 3
fields:
Info: This is a field where the information has to be stored.
llink: This is a pointer field which contains address of the left node or previous node in the
list.
rlink: This is a pointer field which contains address of the right node or next node in the list.
And the llink of first node contains address of the last node whereas rlink of the list node
contains address of the first node.
Now we will see the advantage of circular linked list:
a) As in normal doubly linked list, we can traverse the doubly linked circular list in both
directions.
b) In normal doubly linked list, given the address of the first node we have to traverse till the
end to get the address of the last node. The left link of the first node gives the address of the
last node.
Insert a node at the front end:
Step 1: Create a node: This can be done using getnode() function and copying item 5 as:
temp=getnode();
tempinfo=item;
templlink=temprlink=temp;
Step 2: Insert into empty list: If the list is empty, the above created node itself should be
returned as the first node.

If the above condition fails, it means that is already existing. The new node temp which has
to be inserted at the front end and the existing list can be pictorially represented as:
Now node temp can be inserted at front end using following steps:
Step 3: Obtain the address of the last node: The last node of the list can be obtained using
llink of the first node. The code can be written as:
last=firstllink; //get address of last node
Now the linked list can be pictorially represented as:
Step 4: Link the new node created with first node: This can be done by copying first into
rlink of temp and copying temp into llink of first node as:
The code can be written as:
temprlink=first;
firstllink=temp;
Step 4: Make new node created as the first node: This can be done by copying temp to
rlink of last node and copying last node into llink of new first node (i.e. templlink)
lastrlink= temp;
templlink=last;
Step 5: Return the first node: After modifying the list, always we have to return the address
of the first node. In the above list, temp is the first node and it can be returned using the
statement:
return temp;
C function to insert an item at front end:
NODE insert_front(int item node, NODE first)
NODE temp, last;
temp=getnode();
tempinfo=item;
if(first==NULL) return temp; //create the node first time
temprlink=first; //link the first node with new node
firstllink=temp;
lastrlink= temp; //link the last node with new node
templlink=last;
return temp;
}
Insert a node at rear end:
Step 1: Create a node: This can be done using getnode() function and copying item 5 as:
temp=getnode();
tempinfo=item;
Step 2: Insert into empty list: If the list is empty, the above created node itself should be
returned as the first node as:
if(first==NULL) return temp; //create the node first time
If the above condition fails, it means that is already existing. The new node temp which has
to be inserted at the front end and the existing list can be pictorially represented as:
Now node temp can be inserted at rear end using following steps:
Step 3: Obtain the address of the last node: The last node of the list can be obtained using
llink of the first node. The code can be written as:
Now the linked list can be pictorially represented as:
Step 4: Link the new node created with first node: This can be done by copying temp into
rlink of last and copying last into llink of temp node as:
lastrlink=temp;
templlink=last;
Step 4: Make new node created as the last node: This can be done by copying temp to llink
of first node and copying first node into rlink of temp node(i.e. temprlink) as:
firstllink=temp;
temprlink=first;
Step 5: Return the first node: After modifying the list, always we have to return the address
of the first node. This can be done using statement:
return temp;
C function to insert an item at the rear end of the list:
NODE insert_rear(int item, NODE first)
NODE temp, last;
temp=getnode();
tempinfo=item;
if(first==NULL) return temp; //insert the node for the first time
lastrlink=temp; //link the last node with new node
templlink=last;
firstllink=temp; //link the first node with new node
temprlink=first;
return temp;
Delete a node from front end:
Step 1: List is empty: If the list is empty, it is not possible to delete a node from the list. In
such case, we display the message “List is empty” and return NULL. The code can be written
as:
if(first==NULL)
printf(“List is empty\n”);
return NULL;
}
Step 2: Delete if there is only one node: A list having one node can be written as:
if(firstrlink==first)
free(first);
return NULL;
When control comes out of the above if-statement, it means that the list has more than one
Step 3: Obtain the address of the second node and the last node: The rlink of first node
gives the second node and llink of first node gives the last node as:
last=firstllink;
Step 4: Make second node as first node: It is achieved by copying last to left link of second
node and copying second to rlink of last node as:
secondllink=last;
lastrlink=second;
Now first node is isolated and linked list look like:

Step 5: Delete the front end: Front node can be deleted using free() function.
free(first);
Step 6: Return address of the new first node: The variable second now contains address of
the new first node and it can be returned using the statement:
return second;
C function to delete an item from the front end of the list:
NODE delete_front(NODE first)
NODE second, last;
{
printf(“list is empty cannot delete\n”);
return NULL; //we can replace NULL with first also
if(firstrlink==first) //delete if there is only one node
free(first);
return NULL;
second=firstrlink; //obtain the address of second node
last=firstllink; //obtain the address of last node
secondllink=last; //make second node as new first node
lastrlink=second;
printf(“item deleted=%d\n”,firstinfo); //delete the old first node
free(first);
return second; //return second node as first node
Delete a node from rear end:
such case, we display the message “List is empty” and return NULL. The code can be written
as:
if(first==NULL)
return NULL;
}
Step 2: Delete if there is only one node: A list having one node can be written as:
if(firstrlink==first)
free(first);
return NULL;
When control comes out of the above if-statement, it means that the list has more than one
Step 3: Obtain the address of the last node and its predessor: The llink of first node gives
the last node and llink of last gives its predessor as:
last=firstllink;
prev=lastllink;
Step 4: Make last but one node as last node: It is achieved by copying first to right link of
prev and copying prev to llink of first node (as dotted lines) as:
prevrlink=first;
firstllink=prev;
Step 5: Delete the last node: Last node can be deleted using free() function.
printf(“item deleted=%d\n”,lastinfo);
free(last);
Step 6: Return address of the first node: The variable first contains address of the first
node and it can be returned using the statement as:
return first;
C function to delete an item from rear end of the list:
NODE delete_rear(NODE first)
NODE last, prev;
return NULL;
if(firstrlink==first) //only one node is present and delete it
{
free(first); //return to the availability list
return NULL; //list is empty so return NULL
last=firstllink; //obtain address of the last node
prev=lastllink; //obtain address of last but one node
prevrlink=first; //adjust pointers such that new last node and first node are linked
firstllink=prev;
free(last); //delete the old last node
Display the contents of linked list:
void display(NODE first)
NODE cur, last;
if(first==NULL)
return NULL;
printf(“the contents of singly linked list\n”);
cur=first;
last=firstllink;
while(cur!=last)
cur=currlink;
Circular doubly linked list with header node:
This list is primarily used in structures that allow access to nodes in both directions. An
empty circular doubly linked list with a header node can be represented as in this figure
below where llink and rlink of a header node points to itself.
The main advantage of using doubly linked circular with a header node is that while
designing a function we need not consider any extreme cases. Assume that list is existing and
write a function to insert an item at the front end. The function works for all other cases (i.e.
even if list is empty or if list has only one node or more than one node).
Insert a node at front end:
Consider a list
Step 1: Create a node and copy the item to be inserted: This can be pictorially
represented as:
temp=getnode();
tempinfo=item;
Step 2: Get address of the first node: The right link of header node gives the address of the
first node. Copying rlink of head to first as:
first=headrlink; //get the address of the first node
Step 3: Insert at front end: The node temp has to be inserted between head and first as:
templlink=head; //insert temp before head
headrlink=temp;
temprlink=first; //insert temp before first
firstllink=temp;
Step 3: Return the header node: Using header node, any node can be accessed. So, always
we return the address of header node. This can be done using the statement:
return head;
C function to insert a node at the front end:
NODE insert_front(int item, NODE head)
NODE temp, first;
temp=getnode();
tempinfo=item;
first=headrlink; //get the address of the first node
templlink=head; //insert temp before head
headrlink=temp;
temprlink=first; //insert temp before first
firstllink=temp;
return head;
Insert a node at rear end:
Consider a list
Step 1: Create a node and copy the item to be inserted: This can be pictorially
represented as:
temp=getnode();
tempinfo=item;
Step 2: Get address of the last node: The left link of header node gives the
address of the last node. Copying llink of head to last we get the list as:
last=headllink; //get the address of the last node
Step 3: Insert at the rear end: The node temp has to be inserted after last as:
lastrlink=temp;
templlink=last;
Since temp is the last node, rlink of temp should contain address of header node and llink of
header node should contain the address of last node i.e. temp. This can be pictorially
represented as:
temprlink=head;
headllink=temp;
Step 4: Return the header node: Using the header node, any node can be accessed. So
always we return the address of header node. This can be done using statement.
return head;
C function to insert a node at rear end:
NODE insert_rear(int item, NODE head)
NODE temp, last;
temp=getnode();
tempinfo=item;
last=headllink; //get the address of the last node
lastrlink=temp; //insert temp at the end
templlink=last;
temprlink=head; //make temp as the last node
headllink=temp;
return head;
Delete a node from front end:
such case, we have to display the message “List is empty” and return head.
if(headrlink==head)
printf(“list is empty\n”);
return head;
If the above condition fails, it means that list is existing. Consider the following list:
We can delete an element from the front end using following steps:
Step 2: Get the first node: The right link of head contains address of the first node and copy
it into first as:
first=headrlink;
Step 3: Get the second node: The right link of first contains address of the second node and
copy it into second node as:
Step 4: Isolate the first node: This can be done by connecting head and second node as:
headrlink=second;
secondllink=head;
Step 5: Remove the first node: The first node can be removed as shown in this figure:
free(first);
Step 6: Return the header node: Using the header node, any node can be accessed. So
always we return the address of header node. This can be done using the statement as:
return head;
C function to delete a node from the front end:

NODE delete_front(NODE head)
NODE first, second;
if(headrlink==head) //check for empty list
{
return head;
first=headrlink; //obtain address of first node
second=firstrlink; //obtain address of second node
headrlink=second; //link header node as with second node
secondllink=head;
free(first); //delete the first node
return head; //return the address of last node
Delete a node from rear node:
such case, we have to display the message “List is empty” and return head.
if(headrlink==head)
return head;
}
If the above condition fails, it means that list is existing. Consider the following list:
We can delete an element from the front end using following steps:
Step 2: Get the last node: The llink of head contains address of the last node and copy it into
last as:
last=headllink;
Step 3: Get the last but one node: The left of last contains address of the last but one node
and copy it into prev as shown in this figure:
prev=lastllink;
Step 4: Isolate the last node: This can be done by connecting head and prev node as:
headllink=prev;
prevrlink=head;
Step 5: Remove the last node: This node can be removed as:
free(last);
Step 6: Return the header node: Using the header node, any node can be accessed. So,
always we return the address of header node. This can be done using the statement:
return head;
C function to delete a node from the rear end:
NODE delete_rear(NODE head)
NODE last, prev;
return head;
last=headllink; //obtain address of last node
prev=lastllink; //obtain address of last but one node
headllink=prev; //isolate the last node
prevrlink=head;
printf(“item deleted=%d\n”,lastinfo); //delete the last node
free(last);
return head; //return the address of the last node
}
Display the contents of circular doubly linked list with header node:
void display(NODE head)
NODE cur;
return head;
printf(“contents of doubly linked list\n”);
cur=headrlinnk;
while(cur!=head)
printf(“%d\n”,curinfo);
cur=currlink;
Application of linked list:
a) Evaluation of polynomials
b) Addition of polynomials
c) Multilinked data structure (Eg: sparse matrix)
d) Arithmetic operation on long positive numbers
e) In symbol table construction (compiler design)
Linked list representation of stack: We know that stack is a special type of data structure
where elements are inserted at one end and elements are deleted from the same end. That is,
if an element is inserted at front end, an element has to be deleted from the front end. If an
element is inserted at rear end, an element has to be deleted from rear end. Thus stack can be
implemented using the following functions:
a) insert_front()
b) delete_front()
c) display()
OR
a) insert_rear()
b) delete_rear()
c) display()
Linked list representation of Queue: We know that queue is a special type of data structure
where elements are inserted at one end and elements are deleted at the other end. It is a FIFO
data structure that is if an element is inserted at front end, an element has to be deleted from
rear end. If an element is inserted at rear end, an element has to be deleted from the front end.
So the queue can be implemented using the function:
insert_front()
delete_rear()
display()
OR
insert_rear()
delete_front()
display()
Trees
Definition:
A tree is a set of finite set of one or more nodes that shows parent child relation such that:
a) There is a special node called the root node
b) The remaining node are partitioned into disjoint subsets T1, T2, T3, T4……Tn, n>=0
where T1, T2, T3, T4……Tn which are all children of root node are themselves trees called
subtrees.
Eg: Consider the following tree. Let us identify the root node and various subtrees:
 Here there are 8 nodes: A, B, C, D, E, F, G, H
 A is root here.
 We normally draw the trees with root at the top. The node B, C, D are children of
node A and hence there are 3 subtree identified by B, C and D.
 The node A is parent of B, C and D whereas D is the parent of G and H.
Basic terminologies:
a) Root node: A first node written at the top is root node. Root node does not have the
parent. Here the node 100 is the root node.
b) Child: The node obtained from parent node is called child. A parent node can have zero or
more child nodes. Eg:
 50 and 60 are children of 100

 70 is child of 50
c) Siblings: 2 or more node having the same parent are called siblings. Eg:
 50 and 60 are siblings since they have same parent 100.
d) Ancestors: The nodes obtained in the path from the specified node x while moving
upwards towards the root node are called ancestors. Eg:
 100 is the ancestor of 50 and 60

 60 is the ancestor of 35, 30, 80 and 40
 50 and 100 are the ancestors of 70
 60 and 100 are the ancestors of 80, 40, 35,30
 80, 60 and 100 are the ancestors of 35 and 30
e) Descendants: The node in the path below the parent are called descendants. In other
words, the nodes that are all reachable from a node x while moving downwards are all called
descendants of x. For eg:
 All the nodes below 100 are descendants of 100.

 All the nodes below 50 are descendants of 50 and so on.
f) Left descendants: The node that lie towards left subtree of node x are called left
descendants. Eg:
 50 and 70 are left descendant of 100

 80, 35 and 30 are the left descendant of 60
 35 and 80 are left descendant of 60
g) Right descendants: The node that lie towards right subtree of node x are called left
descendants. Eg:
 The right descendant of 100 are 60, 80, 40, 35 and 30

 The right descendant of 80 is 30
h) Left subtree: All the nodes that are all left descendant of a node x form the left subtree of
x. Eg:
 The left subtree of 100 are 50 and 70

 The left subtree of 60 are 80, 35 and 30
i) Right subtree: All the nodes that are all right descendant of a node x form the right subtree
of x. Eg:
 The right descendant of 100 are 60, 80, 40, 35 and 30

j) Parent: A node having left subtree or right subtree or both is said to be a parent node for
the left subtree and/or right subtree. Eg:
 The parent for 50 and 60 is 100.
 The parent for 70 is 50.
k) Degree: The number of subtrees of a node is called its degree. Eg:
 The node 100 has 2 subtrees. So degree of node 100 is 2.

 The node 50 has one subtree. So degree of node 50 is 1.
 The node 70 has no subtree. So degree of node 70 is 0.
l) Leaf: A node in a tree that has a degree of zero is called a leaf node. In other words, a node
with an empty left child and an empty right child is called leaf node. It is also called a
terminal node. Eg: 70, 35, 30 and 40 are the leaf nodes.
m) Internal nodes: The nodes except leaf node in a tree are called internal nodes. Eg: 100,
50, 60 and 80 are internal nodes.
n) External nodes: The NULL link of any node in a tree is an external node. Eg: rlink of 50,
rlink and llink of nodes 70, 35, 30 and 40 are all external nodes.
o) Level: The distance of a node from the root is called level of the node.
 The distance from root to itself is 0. So, level of root node is 0.

 The node 50 is at a distance of 1 node from root node. So its level is 1.
 The node 70 is at a distance of 2 nodes from root node. So its level is 2.
 The node 35 and 30 are at a distance of 3 nodes from the root node. So their levels are
3.
 The level of each node is known in example.
p) Height (depth): The height of the tree is defined as the maximum level of any leaf in the
tree. For eg: height of the tree is 4.
Representation of trees:
1) List representation: Now let us see how a tree is represented using lists.
 The root node comes first.
 It is immediate followed by a list of subtree of that node.
 It is recursively repeated for each subtree. Eg:
The above tree can be represented using list as:
We can see linked list representation that:
 Since there are 3 children for node A in the tree, there are 3 nodes to the right of A in
the list representation.
 A’s first child is B, 2nd child is C and 3rd child is D and they are shown using down
links in list representation.
 Since there are 2 children for node B in the tree, there are 2 nodes to the right of B in
 Since there is only 1child for C in the tree, there is only 1 node to the right of C in the
list representation.
 Since there are 3 children for node D in the tree, there are 3 nodes to the right of D in
2) Left-child Right-sibling representation:
Left-child Right-sibling representation of a given tree can be obtained as:

 The left pointer of a node in the tree will be the left child in this representation.
 The remaining children of node in the tree are inserted horizontally to the left child in
the representation. Eg: Consider this tree:
The left-child Right-sibling representation of a tree can be written as:
We can observe from above representation that:
 A’s left child is B in the tree. So A’s left child is B in the representation.
 A’s remaining children such as C and D in the tree are inserted horizontally to node B
in the representation.
 B’s left child is E in the tree. So, B’s left child is E in the representation.
 B’s remaining children such as F in the tree are inserted horizontally to node E in the
representation.
 Similarly, D’s left child is H in the tree. So, D’s left child is H in the representation.
 D’s remaining children such as I and J in the tree are inserted horizontally to H in the
representation.
Degree of a node: 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'.
Eg: Degree of B is 3, A is 2 and of F is 0
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'.
Depth: In a tree data structure, the total number of edges 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'.
Why Tree?
Unlike Array and Linked List, which are linear data structures, tree is hierarchical (or non-
linear) data structure.
1) One reason to use trees might be because you want to store information that naturally forms
a hierarchy. For example, the file system on a computer: file system
2) If we organize keys in form of a tree
3) We can insert/delete keys in moderate time.
Advantages of Trees
Trees are so useful and frequently used, because they have some very serious advantages:
a) Trees reflect structural relationships in the data.
b) Trees are used to represent hierarchies.
c) Trees provide an efficient insertion and searching.
d) Trees are very flexible data, allowing to move subtrees around with minimum effort.
Properties of binary tree:
1) The maximum number of nodes on level i of a binary tree=2i for i>=0
The number of nodes at level 0=1=20
……………………………………………………
The number of nodes at level i=2i
2) The maximum number of nodes in a binary tree of depth k=2k-1
3) The number of leaf node is equal to number of nodes of degree 2.

Types of binary tree:
a) Strictly binary tree
b) Full binary tree
c) Skewed binary tree
d) Complete binary tree
a) Strictly binary tree: A binary tree having 2i nodes in any given level i is called strictly
binary tree. Here, every node other than the leaf node has 2 children. A binary tree in which
every node has either two or zero number of children is called Strictly Binary Tree. Strictly
binary tree is also called as Full Binary Tree or Proper Binary Tree or 2-Tree.
Here the number of nodes at level 0 = 20= 1

b) Full binary tree: A Binary Tree is a full binary tree if every node has 0 or 2 children. The
following are the examples of a full binary tree. We can also say a full binary tree is a binary
tree in which all nodes except leaf nodes have two children.
In a Full Binary Tree, number of leaf nodes is the number of internal nodes plus 1
L=I+1
Where L = Number of leaf nodes, I = Number of internal nodes
c) Skewed tree: A skewed tree is a tree consists of only left subtree or only right subtree. A
tree with only left subtree is called left skewed binary tree and a tree with only right subtree is
called right skewed binary tree.
d) Complete binary tree: A complete binary tree is a binary tree in which every level, except
possibly the last level is completely filled. If the node in the last level are not completely filled,
then all the nodes in that level should be filled only from left to right. For example, all trees
shown below are complete binary trees.
The tree shown below is not complete binary tree since the node in the last level are not filled
from left to right. There is an empty left child for node 5 in figure d) and there is an empty right
child for node 5 in figure e). All the nodes should be as left as possible.
Binary tree representation:
a) Linked list representation (uses dynamic allocation technique)
In a linked list representation, a node in a tree has 3 fields:
a) Info – which contains the actual information
b) llink – which contains address of the left subtree
c) rlink – contains address of the right subtree.
So, a node can be represented using self-referential structure as:
struct node
int info;
struct node *llink;
struct node *rlink;

};
typedef struct node * NODE;
The pictorial representation of a typical node in a binary tree is:
The pictorial representation of above node can be written as:
A pointer variable root can be used to point to the root node always. If the tree is empty, the
pointer variable root points to NULL indicating the tree is empty. The pointer variable root
can be declared and initialized as:
NODE root=NULL;
Or
struct node * root=NULL;
Memory can be allocated or deallocated using the C function malloc() or calloc()
b) Array representation (uses static allocation technique): A tree can be represented using
an array, which is called sequential representation.
 Here in this figure the node is numbered sequentially from 0.
 The node with position 0 is considered as root node.
 If an index i is 0, it gives the position of the root node.
 Given the position of any other node I, 2i+1 gives the position of the left child and
2i+2 gives the position of the root child.
 If i is the position of the left child, i+1 gives the position of right child
 If i is the position of the right child, i-1 gives the position of the left child.
 Given the position of any node i, the parent position is given by (i-1)/2. If I is odd, it
points to the left child otherwise, it points to the right child.
A tree can be represented using arrays in 2 different methods as:
Method 1: In this, some of the location may be used and some may not be used. For this, flag
field like used is used to indicate whether a memory location is used to represent a node or
not. If flag field used is 0, the corresponding memory location is not used and indicates the
absence of node at that position.
Each node contains 2 fields:
a) info – where information is stored.
b) used indicates the presence or the absence of a node.
The structure declaration for this is:

#define MAX_SIZE 200
struct node
int info;
int used;
};
typedef struct node NODE;
An array a of type NODE can be used to store different items and the declaration for this is:
NODE a[MAX_SIZE];
Method 2: An alternate representation is that, instead of using a separate flag field used to
check the presence of node by initializing each location of the array to 0 indicating the node
as not used. Non zero value in the location indicates the presence of the node.
Operation on binary tree:
a) Insertion
b) Searching
c) Deletion
d) Traversal
a) Insertion
Eg used to insert:
b) Searching:
Eg used for search:
c) Delete:
d) Traversal: Traversing is a method of visiting each node of a tree exactly once in a
systematic order. During traversal, we may print the info field of each node visited.
Different traversal technique of a binary tree:
a) Preorder traversal
b) Postorder traversal
c) Inorder traversal
a) Preorder traversal: It is recursively defined as:
1) Process the root Node [N]
2) Traverse the Left subtree in Preorder [L]
3) Traverse the Right subtree in Preorder [R]

Eg: Traverse the following tree using Preorder traversal:
Function to traverse the tree in Preorder:
void preorder(NODE root)

{
if(root==NULL) return;
printf(“%d”, root🡪info); //visit node
preorder(root🡪llink); //visit left subtree in preorder
preorder(root🡪rlink); //visit right subtree in preorder
b) Postorder traversal: It is recursively defined as:
Eg: Traverse the following tree using postorder traversal:

Function to traverse the tree in Postorder:
void postorder(NODE root)
postorder(root🡪llink); //visit left subtree in preorder
postorder(root🡪rlink); //visit right subtree in preorder
c) Inorder traversal: It is recursively defined as:

Eg: Traverse the following tree using inorder traversal:
Function to traverse the tree in Inorder:
void inorder(NODE root)
inorder (root🡪llink); //visit left subtree in preorder
inorder (root🡪rlink); //visit right subtree in preorder
C function to print the tree in the tree form:
void display(NODE root, int level)

{
int i;
display(root🡪rlink, level +1);
for(i=0;i<level;i++) printf(“ “);
printf(“%d\n”,root🡪info);
display(root🡪llink,level+1);
Eg 1: Given a binary tree. What is preorder, inorder and postorder traversal?
Preorder traversal: 100, 20, 10, 30, 200, 150, 300
Inorder traversal: 10, 20, 30, 100, 150, 200, 300
Postorder traversal: 10, 30, 20, 150, 300, 200, 100
Eg 2: The preorder traversal sequence of a binary search tree is: 30, 20, 10, 15, 25, 23, 39,
35, 42. What is the postorder traversal sequence of the same tree?
We draw a binary search tree using these traversal results.
The binary search tree so obtained is as shown:

Postorder Traversal: 15, 10, 23, 25, 20, 35, 42, 39, 30.
Binary search tree:
A binary search tree is a tree in which for each node say x in the tree, elements in the left
subtree are less than info (x) and elements in the right subtree are greater than info (x). Every
node in the tree should satisfy this condition, if left subtree or right subtree exists. A binary
search tree can be empty.
Eg for binary search tree:
Traversal of a binary search tree is same as binary tree.

Construct a Binary Search Tree (BST):
When elements are given in a sequence,
a) Always consider the first element as the root node.
b) Consider the given elements and insert them in the Binary Search Tree one by one.
Eg: Construct a Binary Search Tree (BST) for the following sequence of numbers:
50, 70, 60, 20, 90, 10, 40, 100
Insert 50:
Insert 70: As 70 > 50, so insert 70 to the right of 50.
Insert 60: As 60 > 50, so insert 60 to the right of 50. As 60 < 70, so insert 60 to the left of 70.
Insert 20: As 20 < 50, so insert 20 to the left of 50.

Insert 90: As 90 > 50, so insert 90 to the right of 50. As 90 > 70, so insert 90 to the right of
70.
Insert 10: As 10 < 50, so insert 10 to the left of 50. As 10 < 20, so insert 10 to the left of 20.
Insert 40: As 40 < 50, so insert 40 to the left of 50. As 40 > 20, so insert 40 to the right of 20.
Insert 100: As 100 > 50, so insert 100 to the right of 50. As 100 > 70, so insert 100 to the
right of 70. As 100 > 90, so insert 100 to the right of 90.
Eg 1: Suppose the numbers 7, 5, 1, 8, 3, 6, 0, 9, 4, 2 are inserted in that order into an initially

empty binary search tree. The binary search tree uses the usual ordering on natural numbers.
What is the inorder traversal sequence of the resultant tree?
Inorder Traversal: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Eg 2: The preorder traversal sequence of a binary search tree is: 30, 20, 10, 15, 25, 23, 39,
35, 42. What is the postorder traversal sequence of the same tree? Left, right, root
Postorder Traversal: 15, 10, 23, 25, 20, 35, 42, 39, 30
Other common operations on binary search tree:
a) Insertion
b) traversal
a) Insertion:
Step 1: The item read from the keyboard must be stored in a node. This is achieved using
malloc() function with the help of getnode() function.
temp=getnode();
tempinfo=item;
templlink=NULL;
temprlink=NULL;
Step 2: If tree does not exist, then return the above node itself as the root node.
if(root==NULL) return temp;
Step 3: If tree already exists, root will not be NULL. In such case, we have to insert the node
created in step 1 at the appropriate place. We k now that in BST, items towards left subtree of
a node x will be less than info (x) and the items in the right subtree are greater or equal to
info (x).
Consider BST. Let temp with info of 140 is the node to be inserted.
Now we have to find appropriate position to insert. Let us assume that the variable root always
points to the root node of the tree. Since search starts from the root, we use 2 pointers cur and
prev to find the appropriate position in the tree. The pointer variable prev always points to
parent of cur node. Initially cur points to root node and prev points to NULL as:
prev=NULL;
cur=root;
Now as long as the item is less than info (cur), keep updating pointer variable cur towards left
using the statement:
cur=curllink;
Otherwise update cur towards right using the statement:
cur=currlink;
Before updating cur towards left or right, save its address in prev so that the pointer variable
prev always points to the parent node of cur. Now, the code can be written as:
prev=cur;
if(item<curinfo)
cur=curllink;
else
cur=currlink;
Note that when we update cur towards left or right, it may become NULL. In such case, we
have found the appropriate position to insert and stop updating cur. So, the code can be
repeatedly executed as long as cur is not NULL.
while (cur! =NULL)
prev=cur;
if(item<curinfo)
cur=curllink;
else
cur=currlink;
Once cur points to NULL, insert the node temp towards left (prev) if item is less than info
(prev), otherwise insert towards right. This can be done using the statement:
if(item<previnfo)
prevllink=temp;
else
prevrlink=temp;
Finally, we return the address of the root node using the statement as:
return root;
To insert an item into a binary search tree (duplicate elements):
NODE insert(int item, NODE root)
NODE temp, cur, prev;
temp=getnode(); //create a node and copy appropriate data
tempinfo=item;
templlink=NULL;
temprlink=NULL;
if(root==NULL) return temp; //insert a node for the first time
prev=NULL; //find the position to insert
cur=root;
while(cur!=NULL)
prev=cur; //obtain parent position
if(item<curinfo);
cur=curllink; //obtain left child position
else
cur=currlink; //obtain right child position
if(item<previnfo) //if node to be inserted < parent
prevllink=temp; //insert towards left of the parent
else
prevrlink=temp; //else insert towards right of the parent
return root; //return the root of the tree
}
Note: In the above function, observe that if an item is less than the node, it is inserted towards
left. Otherwise, it is inserted towards right. So, duplicate items are also inserted towards right.
So, to avoid duplicate elements, we check whether the item is same as info of a node. If so,
donot insert. The code can be written as:
prev=cur;
if(item==curinfo)
printf(“Duplicate items not allowed\n”);
free(temp);
return root;
if(item<curinfo)
else
To insert an item into a binary search tree (No duplicate items):
NODE insert(int item, NODE root)
NODE temp, cur, prev;
temp=getnode(); //create a node and copy appropriate data
tempinfo=item;
templlink=NULL;
temprlink=NULL;
if(root==NULL) return temp; //insert a node for the first time
prev=NULL; //find the position to insert
cur=root;
while(cur!=NULL)
{
prev=cur; //obtain parent position
if(item==curinfo) //donot insert duplicate item
printf(“duplicate items not allowed\n”);
free(temp);
return root;
if(item<curinfo)
else
if(item<previnfo) //if node to be inserted < parent
prevllink=temp; //insert towards left of the parent
else
prevrlink=temp; //else insert towards right of the parent
return root; // return the root of the tree
Unit 4
Non Linear data structure – tree data structure 2
Expression tree:
A sequence of operators and operands that reduces to a single value is called an expression.
Now let us see what is an expression tree?
An expression tree is a binary tree that satisfy the following properties:
a) Any leaf is an operand.
b) The root and internal nodes are operators
c) The subtree represents sub expressions with root of the subtree as an operator.
Steps to make expression tree:
Now let us see how an infix expression can be written using expression tree?
Eg: 1) a+b
2) a+ b –c
Step 1:
Step 2:
Step 3:
3) a + b * c $ e ^ f
Step 1:
Step 2:
Step 3:
Step 4:
4) a $ b * c – d ^ e
Step 1:
Step 2:
Step 3:
Step 4:
5) ((a * b ^ c) – (d + e)) * (f ^ k – h)
Step 1:
Step 2:
Step 3:
Step 4:
Step 5:
Step 6:
Create a binary tree for the postfix expression:
Now let us see what is the procedure to obtain an expression tree from the postfix expression?
The procedure to be followed while creating an expression tree using postfix expression as:
a) Scan the symbol from the left to right.
b) Create a node for the scanned symbol.
c) If the symbol is an operand push the corresponding node onto the stack.
d) If the symbol is an operator, pop one node from the stack and attach to the right of the
corresponding node with an operator. The first popped node represents the right operand. Pop
one more node from the stack and attach to the left. Push the node corresponding to the
operator on to the stack.
e) Repeat through step 1 for each symbol in the postfix expression. Finally, when scanning of
all the symbol from the postfix expression is over, address of the root node of the expression
tree is on top of the stack.
Function to create an expression tree for the postfix expression:
NODE creat_tree(charpostfix[])
NODE temp, st[20];
int i, k;
char symbol;
for(i=k=0;(symbol=postfix[i]!= ‘\0’;i++)
temp=getnode(); //obtain a node for each operator
tempinfo=symbol;
templlink=temprlink=NULL;
if(isalnum(symbol))
st[k++]=temp; //push the operand node on to the stack
else
temprlink=st[--k]; //obtain 2nd operand from stack
templlink=st[--k]; //obtain 1st operand from stack
st[k++]=temp; //push operator node on to stack
return st[--k]; //Return the root of the expression tree
}
Evaluation of expression: Now let us see “How to evaluate the expression?” In the
expression trees, whenever an operator is encountered, evaluate the expression in the left
subtree and evaluate the expression in the right subtree and perform the operation.
The recursive definition to evaluate the expression represented by an expression tree is:
Eval(root)= Eval(rootllink op Eval(rootrlink) if rootinfo is operator
Rootinfo – ‘0’ if rootinfo is operand
Creation of a binary search tree and traversal techniques:
C program to create a tree and traverse the tree array representation:
#include<stdio.h>
#include<process.h>
# define MAX_SIZE 100
typedef int NODE;
/*function to insert an item*/
void insert(int item, NODE a[])
int i;
i=0; //root node
while(i<MAX_SIZE && a[i]!=0) //obtain position where to insert
if(item<a[i])
i=2*i+1; //move towards to left link
else
i=2*i+2; //move towards to right link
a[i]=item; //insert the item
}
void inorder(NODE a[], int i)
if(a[i]==0) return;
inorder(a,2*i+1); //traverse left subtree
printf(“%d”,a[i]); //visits the node
inorder(a,2*i+2); //traverse right subtree
void preorder(NODE a[], int i)
if(a[i]==0) return;
preorder(a,2*i+1); //traverse left subtree
preorder(a,2*i+2); //traverse right subtree
void postorder(NODE a[], int i)
if(a[i]==0) return;
postorder(a,2*i+1); //traverse left subtree
postorder(a,2*i+2); //traverse right subtree
void main()
NODE a[MAX_SIZE];
int item, choice, i;
for(i=0; i< MAX_SIZE; i++) a[i] =0;
for(;;)
{
printf(“1-insert, 2- inorder\n”);
printf(“3-preorder, 4- postorder\n”);
printf(“5-Exit\n”);
printf(“enter the choice\n”);
scanf(“%d”,&choice);
switch(choice)
case 1: printf(“enter the item to be inserted\n”);
scanf(“%d”,&temp);
insert(item,a);
break;
case 2: if(a[i]==0)
printf(“tree is empty\n”);
else
printf(“the inorder traversal is\n”);
inorder(a,0);
break;
default: exit(0);
}
}
Advantages and disadvantages:
The sequential representation is simple and it saves space if the tree is complete or almost
complete as there is no need to have fields such as left-link, right-link etc. If the tree is not
complete or not almost complete binary tree, too much space may be wasted. The index i used
to move downward while doing some operation should not exceed the array bound i.e.
MAX_SIZE. This is advantageous only when the number of items in the tree is known in
advance.
The linked representation is useful most of the time during repeated deletion or manipulations,
which can be easily done by adjusting the links and where the number of items in the tree is
unpredictable.
Expression tree:
Eg 1): a + (b * c) + d * (e + f)
2) (a+b)*c+7
3) ((5 + z) / -8) * (4 ^ 2)
4) (((2+3)*9)+7)
Threaded binary tree:
Now let us see “what are the disadvantages of binary trees?” The various disadvantages of the
binary tree are:
a) In a binary tree, more than 50% of link fields have \0 (null) values and more memory space
is wasted by storing \0 (null) values.
b) Traversing a tree with binary tree is time consuming. This is because, the traversal of a tree
either uses implicit stack (un case of recursive programs) or explicit stack (in case of iterative
programs). Whatever it is stack is must. Most of the time is spent in pushing and popping
activities during traversing.
c) Computations of predecessor and successor of given nodes is time consuming.
d) In binary tree, only downward movements are possible.
All these disadvantages can be overcome using threaded binary tree.
Definition of Threaded binary tree:
In a binary tree, more than 50% of link fields have \0 (null) values and more space is wasted.
By the presence of \0 (null) values. These link fields which contains \0 characters can be
replaced by address of some nodes in the tree which facilitate upward movement in the tree.
These extra links which contains address of some nodes (pointers) are called threads and the
tree is termed as threaded binary tree. A threaded binary tree is a binary tree which contains
threads (i.e. address of some nodes) which facilitate upward movement in the tree.
Types of threaded binary tree:
This is based on the traversal technique.
3 types of threaded binary tree:
a) In thread binary tree
b) Post-threaded binary tree

c) Pre-threaded binary tree
a) In thread binary tree: In a binary tree, if llink (left link) of any node contains \0 (null) and
if it is replaced by address of the inorder predecessor, then the resulting tree is called left-in
threaded binary tree. In a binary tree, if rlink (right link) of a node is NULL and if it is replaced
by address of inorder successor, the resulting tree is called right in- threaded binary tree. An
in-threaded binary tree or inorder threading of a binary tree is the once which is both left in-
threaded and right in-threaded.
Eg: Consider a binary tree with header node:
In the above binary tree, if the right link of a node is NULL and if it is replaced by the address
of the inorder successor as shown using dotted lines, then the tree is said to be right in threaded
binary tree.
How to implement right in-threaded binary tree in C language?

To implement a right in- threaded an extra field rthread is used. If rthread is 1 the corresponding
right link represents a thread and if rthread is 0 the right link represents an ordinary link
connecting the right subtree. Thus a node can be defined as:
struct node
int info;
struct node *llink; //pointer to the left subtree
struct node *rlink; //pointer to the right subtree
int rthread; //1 indicates the presence of a thread & 0 indicates absence of thread
};
In a binary tree, if the left field is NULL and it is replaced by the inorder predecessor, then
the tree is said to be left in-threaded binary tree. Here also an extra field lthread is used where
1 indicates the presence of a thread and 0 indicates ordinary link connecting the left subtree.
Left in-threaded binary tree:
In-thread binary tree (inorder threading of binary tree):

Thus a node can be defined as:
struct node
int info;
int lthread; //1 indicates the presence of a thread and 0 indicates absence of a thread
};
An inorder threading of a binary tree or in-threaded binary tree is one which is left in-
threaded and right in-threaded. Here two extra fields lthread and rthread as:
struct node
int info;
struct node
int info;

int lthread; //1 indicates a thread else ordinary link
int rthread;
};
Inorder successor for right in-thread:
Consider the right in-threaded binary tree. Given a node X, if rthread is 1, which indicates the
presence of thread, its rlink gives the address of the inorder successor. If rthread is 0, rlink
contains the address of the right subtree. Leftmost node in the right subtree is the inorder
successor.
Function to find inorder successor:
NODE inorder_successor(NODE x)
NODE temp;
temp=xrlink;
if(rthread==1) return temp;
while(templlink!=NULL) //obtain leftmost node in the right subtree
temp=templlink;
return temp;
b) What is pre-threaded binary tree:
In a binary tree, if llink (left link) of any node contains \0 (null) and if it is replaced by address
of the preorder predecessor, then the resulting tree is called left-pre threaded binary tree. In a
binary tree, if rlink (right link) of a node is NULL and if it is replaced by address of preorder
successor, the resulting tree is called right pre-threaded binary tree. A pre-threaded binary tree
or preorder threading of a binary tree is the once which is both left pre-threaded and pre-
threaded.
c) What is post-threaded binary tree:
In a binary tree, if llink (left link) of any node contains \0 (null) and if it is replaced by address
of the postorder predecessor, then the resulting tree is called left post-threaded binary tree. In
a binary tree, if rlink (right link) of a node is NULL and if it is replaced by address of postorder
successor, the resulting tree is called right post-threaded binary tree. A post-threaded binary
tree or postorder threading of a binary tree is the one which both left post-threaded and right
post-threaded.
B- tree:
The B-Trees are specialized m-way search tree. This can be widely used for disc access. A B-
tree of order m, can have maximum m-1 keys and m children. This can store large number of
elements in a single node. So the height is relatively small. This is one great advantage of B-
Trees.
A B-tree of order m is a multiway search tree of order m such that:
a) All leaves are on the bottom level.
b) All internal nodes (except the root node) have at least ceil (m / 2) (nonempty) children.
c) The root node can have as few as 2 children if it is an internal node, and can obviously
have no children if the root node is a leaf (that is, the whole tree consists only of the root
node).
d) Each leaf node must contain at least ceil (m / 2) - 1 keys.
Note that ceil(x) is the so-called ceiling function. It's value is the smallest integer that is greater
than or equal to x. Thus ceil (3) = 3, ceil (3.35) = 4, ceil(1.98) = 2, ceil(5.01) = 6, ceil(7) = 7,
etc.
Eg of B-Tree:
The following is an example of a B-tree of order 5. This means that (other than the root node)
all internal nodes have at least ceil (5 / 2) = ceil (2.5) = 3 children (and hence at least 2 keys).
Of course, the maximum number of children that a node can have is 5 (so that 4 is the maximum
number of keys). According to condition 4, each leaf node must contain at least 2 keys. In
practice B-trees usually have orders a lot bigger than 5.
Why B-tree
The need for B-tree arose with the rise in the need for lesser time in accessing the physical
storage media like a hard disk. The secondary storage devices are slower with a larger capacity.
There was a need for such types of data structures that minimize the disk accesses. Other data
structures such as a binary search tree, AVL tree, red-black tree, etc can store only one key in
one node. If you have to store a large number of keys, then the height of such trees becomes
very large and the access time increases. However, B-tree can store many keys in a single node
and can have multiple child nodes. This decreases the height significantly allowing faster disk
accesses.
Construct a B-tree for the following:
1 12 8 2 25 5 14 28 17 7 52 16 48 68 3 26 29 53 55 45 Construct a B-tree of order 5
The first four items go into the root:
To put the fifth item in the root would violate condition 5. Therefore, when 25 arrives, pick the
middle key to make a new root.
6, 14, 28 get added to the leaf nodes:
Adding 17 to the right leaf node would over-fill it, so we take the middle key, promote it (to
the root) and split the leaf.
7, 52, 16, 48 get added to the leaf nodes

Add 68
Adding 68 causes us to split the right most leaf, promoting 48 to the root, and adding 3 causes
us to split the left most leaf, promoting 3 to the root; 26, 29, 53, 55 then go into the leaves.
Adding 45 causes a split of and promoting 28 to the root then

causes the root to split.
2) Example for m= 5
Def: B Tree of order 5 is an 5-way tree such that
1. All leaf nodes are at the same level.
2. All non-leaf nodes (except the root) have atmost 5 and at least (m/2 children) 2 children.
3. The number of keys is one less than the number of children for non-leaf nodes and atmost
(m-1) 4 and atleast (m/2) 2 for leaf nodes.
4. The root may have as few as 2 children unless the tree is the root alone.
Operations:
Searching:
Searching in B Trees is similar to that in Binary search tree. For example, if we search for an
item 49 in the following B Tree. The process will something like following:
1. Compare item 49 with root node 78. since 49 < 78 hence, move to its left sub-tree.
2. Since, 40<49<56, traverse right sub-tree of 40.
3. 49>45, move to right. Compare 49.
4. match found, return.
Searching in a B tree depends upon the height of the tree.
Inserting
Insertions are done at the leaf node level. The following algorithm needs to be followed in
order to insert an item into B Tree.
1. Traverse the B Tree in order to find the appropriate leaf node at which the node can
be inserted.
2. If the leaf node contains less than m-1 keys, then insert the element in the increasing
order.
3. Else, if the leaf node contains m-1 keys, then follow the following steps.
o Insert the new element in the increasing order of elements.
o Split the node into the two nodes at the median.
o Push the median element upto its parent node.
o If the parent node also contains m-1 number of keys, then split it too by
following the same steps.
Example:
1) Tree of minimum degree ‘t’ as 3 and a sequence of integers 10, 20, 30, 40, 50, 60, 70, 80 and
90 in an initially empty B-Tree.
Initially root is NULL. Let us first insert 10.
Let us now insert 20, 30, 40 and 50. They all will be inserted in root because the maximum
number of keys a node can accommodate is 2*t – 1 which is 5.
Let us now insert 60. Since root node is full, it will first split into two, then 60 will be inserted
into the appropriate child.
Let us now insert 70 and 80. These new keys will be inserted into the appropriate leaf without
any split.
Let us now insert 90. This insertion will cause a split. The middle key will go up to the parent.
Eg: 2) Insert the node 8 into the B Tree of order 5 shown in the following image.
8 will be inserted to the right of 5, therefore insert 8.
The node, now contain 5 keys which is greater than (5 -1 = 4) keys. Therefore, split the node
from the median i.e. 8 and push it up to its parent node shown as follows.
Deletion: Deletion is also performed at the leaf nodes. The node which is to be deleted can
either be a leaf node or an internal node. Following algorithm needs to be followed in order to
delete a node from a B tree.
1. Locate the leaf node.
2. If there are more than m/2 keys in the leaf node, then delete the desired key from the
node.
3. If the leaf node doesn't contain m/2 keys, then complete the keys by taking the
element from eight or left sibling.
o If the left sibling contains more than m/2 elements, then push its largest
element up to its parent and move the intervening element down to the node
where the key is deleted.
o If the right sibling contains more than m/2 elements, then push its smallest
element up to the parent and move intervening element down to the node
where the key is deleted.
4. If neither of the sibling contain more than m/2 elements, then create a new leaf node
by joining two leaf nodes and the intervening element of the parent node.
5. If parent is left with less than m/2 nodes then, apply the above process on the parent
too.
If the node which is to be deleted is an internal node, then replace the node with its in-order
successor or predecessor. Since, successor or predecessor will always be on the leaf node
hence, the process will be similar as the node is being deleted from the leaf node.
Eg 1: Delete the node 53 from the B Tree of order 5 shown in the following figure.
53 is present in the right child of element 49. Delete it.
Now, 57 is the only element which is left in the node, the minimum number of elements that
must be present in a B tree of order 5, is 2. it is less than that, the elements in its left and right
sub-tree are also not sufficient therefore, merge it with the left sibling and intervening element
of parent i.e. 49.
The final B tree is shown as follows.
Application of B tree
B tree is used to index the data and provides fast access to the actual data stored on the disks
since, the access to value stored in a large database that is stored on a disk is a very time
consuming process.
B+ Tree: B+ Tree is an extension of B Tree which allows efficient insertion, deletion and
search operations. In B Tree, Keys and records both can be stored in the internal as well as
leaf nodes. Whereas, in B+ tree, records (data) can only be stored on the leaf nodes while
internal nodes can only store the key values. The leaf nodes of a B+ tree are linked together
in the form of a singly linked lists to make the search queries more efficient.
B+ Tree are used to store the large amount of data which cannot be stored in the main memory.
Due to the fact that, size of main memory is always limited, the internal nodes (keys to access
records) of the B+ tree are stored in the main memory whereas, leaf nodes are stored in the
secondary memory. The internal nodes of B+ tree are often called index nodes.
A B+ tree of order 3 as:
Advantages of B+ Tree
1. Records can be fetched in equal number of disk accesses.
2. Height of the tree remains balanced and less as compare to B tree.
3. We can access the data stored in a B+ tree sequentially as well as directly.
4. Keys are used for indexing.
5. Faster search queries as the data is stored only on the leaf nodes.
B Tree VS B+ Tree
Insertion in B+ Tree:
Step 1: Insert the new node as a leaf node
Step 2: If the leaf doesn't have required space, split the node and copy the middle node to the
next index node.
Step 3: If the index node doesn't have required space, split the node and copy the middle
element to the next index page.
Example: Insert the value 195 into the B+ tree of order 5 shown in the following figure.
195 will be inserted in the right sub-tree of 120 after 190. Insert it at the desired position.
The node contains greater than the maximum number of elements i.e. 4, therefore split it and
place the median node up to the parent.
Now, the index node contains 6 children and 5 keys which violates the B+ tree properties,
therefore we need to split it, shown as follows.
Deletion in B+ Tree
Step 1: Delete the key and data from the leaves.
Step 2: if the leaf node contains less than minimum number of elements, merge down the
node with its sibling and delete the key in between them.
Step 3: if the index node contains less than minimum number of elements, merge the node
with the sibling and move down the key in between them.
Example: Delete the key 200 from the B+ Tree shown in the following figure.
200 is present in the right sub-tree of 190, after 195. delete it.
Merge the two nodes by using 195, 190, 154 and 129.
Now, element 120 is the single element present in the node which is violating the B+ Tree
properties. Therefore, we need to merge it by using 60, 78, 108 and 120.
Now, the height of B+ tree will be decreased by 1.
Properties of a B+ Tree
1. All leaves are at the same level.
2. The root has at least two children.
3. Each node except root can have a maximum of m children and at least m/2 children.
4. Each node can contain a maximum of m - 1 keys and a minimum of ⌈m/2⌉ - 1 keys.
B+ Tree Applications
 Multilevel Indexing
 Faster operations on the tree (insertion, deletion, search)
 Database indexing
Construct B+ tree:
The elements to be inserted are 5,15, 25, 35, 45. Order 3
Insert 5
Insert 15
Insert 25
Insert 35
Insert 45
Searching on a B+ Tree
Some of the steps to be followed to search for data in a B+ Tree of order m. Let the data to be
searched be k.
1. Start from the root node. Compare k with the keys at the root node [k1, k2, k3, ......km - 1].
2. If k < k1, go to the left child of the root node.
3. Else if k ==k1, compare k2. If k < k2, k lies between k1 and k2. So, search in the left child
of k2.
4. If k > k2, go for k3, k4......km-1 as in steps 2 and 3.
5. Repeat the above steps until a leaf node is reached.
6. If k exists in the leaf node, return true else return false.
Searching Example on a B+ Tree
Search k = 45 on the following B+ tree.
1. Compare k with the root node.
k is not found at the root
2. Since k > 25, go to the right child
Go to right of the root
3. Compare k with 35. Since k > 30, compare k with 45

k not found
4. Since k ≥ 45, so go to the right child
5. k is found.
Insertion in B+ Tree:
Step 1: Insert the new node as a leaf node
Step 2: If the leaf doesn't have required space, split the node and copy the middle node to the
next index node.
Step 3: If the index node doesn't have required space, split the node and copy the middle
element to the next index page.
Example: Insert the value 195 into the B+ tree of order 5 shown in the following figure.
195 will be inserted in the right sub-tree of 120 after 190. Insert it at the desired position.
The node contains greater than the maximum number of elements i.e. 4, therefore split it and
place the median node up to the parent.
Now, the index node contains 6 children and 5 keys which violates the B+ tree properties,
therefore we need to split it, shown as follows.
Deletion in B+ Tree
Step 1: Delete the key and data from the leaves.
Step 2: if the leaf node contains less than minimum number of elements, merge down the
node with its sibling and delete the key in between them.
Step 3: if the index node contains less than minimum number of elements, merge the node
with the sibling and move down the key in between them.
Example: Delete the key 200 from the B+ Tree shown in the following figure.
200 is present in the right sub-tree of 190, after 195. delete it.
Merge the two nodes by using 195, 190, 154 and 129.
Now, element 120 is the single element present in the node which is violating the B+ Tree
properties. Therefore, we need to merge it by using 60, 78, 108 and 120.
Now, the height of B+ tree will be decreased by 1.
AVL tree:
AVL tree is a height-balanced binary search tree. That means, an AVL tree is also a binary
search tree but it is a balanced tree. A binary tree is said to be balanced if, the difference
between the heights of left and right subtrees of every node in the tree is either -1, 0 or +1. In
other words, a binary tree is said to be balanced if the height of left and right children of every
node differ by either -1, 0 or +1. In an AVL tree, every node maintains an extra information
known as balance factor. The AVL tree was introduced in the year 1962 by G.M. Adelson-
Velsky and E.M. Landis.
An AVL tree is defined as:

An AVL tree is a balanced binary search tree. In an AVL tree, balance factor of every node is
either -1, 0 or +1
Balance factor of a node is the difference between the heights of the left and right subtrees of
that node. The balance factor of a node is calculated either height of left subtree - height of
right subtree (OR) height of right subtree - height of left subtree.
Balance factor = height of LeftSubtree – height of RightSubtree
Example of AVL Tree:

The above tree is a binary search tree and every node is satisfying balance factor condition. So
this tree is said to be an AVL tree.
Every AVL Tree is a binary search tree but every Binary Search Tree need not be AVL
tree
AVL Tree Rotations

In AVL tree, after performing operations like insertion and deletion we need to check the
balance factor of every node in the tree. If every node satisfies the balance factor condition,
then we conclude the operation otherwise we must make it balanced. Whenever the tree
becomes imbalanced due to any operation we use rotation operations to make the tree balanced.
Rotation operations are used to make the tree balanced.
Rotation is the process of moving nodes either to left or to right to make the tree balanced.
Why AVL Tree?

Let us consider the 2 scenarios that are given below. Both have the same elements arranged in
2 different ways.
When we consider case (a) - the Unbalanced Binary Search Tree:

 If we want to locate 10, it will require 2 tests. That is checking whether the first node
is 10 and then checking whether the second node is 10.
 If we want to locate 50, it requires 6 tests checking each node until you find 50
 Hence, the maximum search effort for this tree data structure is equal to the number of
elements in the tree, otherwise called as Order of n, or simply represented as O(n).
 Thus performance in the worst case scenario, is closer to the sequential search
algorithms such as List.
 In order to make searches faster, we need to balance the unbalanced Binary Search tree
(BST).
Now consider the case (b) - AVL tree:
 If we want to locate a value which is far from the root, say 8, we start by comparing
with the root value 28.
 Since 8 < 28, then we next search the left subtree node and compare 8 with 10.
 Since 8 < 10, then we search the left subtree node 8.
 Since 8 is found, this search needs only 3 tests.
 So the maximum search effort for this tree is O(log n).
 When we compare these 2 samples, we see that even in the worst case scenario, search
effort was reduced from 6 to 3.
Single Left Rotation (LL Rotation)

In LL Rotation, every node moves one position to left from the current position.
Single Right Rotation (RR Rotation)
In RR Rotation, every node moves one position to right from the current position. To
understand RR Rotation, let us consider the following insertion operation in AVL Tree.
Left Right Rotation (LR Rotation)

The LR Rotation is a sequence of single left rotation followed by a single right rotation. In LR
Rotation, at first, every node moves one position to the left and one position to right from the
current position. To understand LR Rotation, let us consider the following insertion operation
in AVL Tree.
Right Left Rotation (RL Rotation)

The RL Rotation is sequence of single right rotation followed by single left rotation. In RL
Rotation, at first every node moves one position to right and one position to left from the current
position. To understand RL Rotation, let us consider the following insertion operation in AVL
Tree.
Rotations:
RL rotation:
Note:
 AVL trees are self-balancing binary search trees.
 In AVL trees, balancing factor of each node is either 0 or 1 or -1
To insert an element in the AVL tree, follow the following steps:

 Insert the element in the AVL tree in the same way the insertion is performed in BST.
 After insertion, check the balance factor of each node of the resulting tree.
Now following 2 cases are possible:
Case 1:
 After the insertion, the balance factor of each node is either 0 or 1 or -1.
 In this case, the tree is considered to be balanced.
 Conclude the operation.
 Insert the next element if any.
Case 2:
 After the insertion, the balance factor of at least one node is not 0 or 1 or -1.
 In this case, the tree is considered to be imbalanced.
 Perform the suitable rotation to balance the tree.
 After the tree is balanced, insert the next element if any.
Rule 1:
After inserting an element in the existing AVL tree,
 Balance factor of only those nodes will be affected that lies on the path from the newly
inserted node to the root node.
Rule 2:
 To check whether the AVL tree is still balanced or not after the insertion,
 There is no need to check the balance factor of every node.
 Check the balance factor of only those nodes that lies on the path from the newly
inserted node to the root node.
Rule 3: After inserting an element in the AVL tree,

 If tree becomes imbalanced, then there exists one particular node in the tree by
balancing which the entire tree becomes balanced automatically.
 To re balance the tree, balance that particular node.
To find that particular node,

 Traverse the path from the newly inserted node to the root node.
 Check the balance factor of each node that is encountered while traversing the path.
 The first encountered imbalanced node will be the node that needs to be balanced.
To balance that node,

 Count three nodes in the direction of leaf node.
 Then, use the concept of AVL tree rotations to re balance the tree.
Construct AVL Tree for the following sequence of numbers:

50, 20, 60, 10, 8, 15, 32, 46, 11, 48
Step-01: Insert 50
Step 2: Insert 20
As 20 < 50, so insert 20 in 50’s left sub tree.
Step 3: Insert 60
 As 60 > 50, so insert 60 in 50’s right sub tree.
Step-04: Insert 10
 As 10 < 50, so insert 10 in 50’s left sub tree.
Step-05: Insert 8
To balance the tree,

 Find the first imbalanced node on the path from the newly inserted node (node 8) to the
root node.
 The first imbalanced node is node 20.
 Now, count three nodes from node 20 in the direction of leaf node.
 Then, use AVL tree rotation to balance the tree.
Step-06: Insert 15

root node.
Step 7: Insert 32
Step-08: Insert 46
Step 9: Insert 11
Step 10: Insert 48

root node.
Operations on an AVL Tree
a) Search
b) Insertion
c) Deletion
Search Operation in AVL Tree:
Step 1 - Read the search element from the user.
Step 2 - Compare the search element with the value of root node in the tree.
Step 3 - If both are matched, then display "Given node is found!!!" and terminate the function
Step 4 - If both are not matched, then check whether search element is smaller or larger than
that node value.
Step 5 - If search element is smaller, then continue the search process in left subtree.
Step 6 - If search element is larger, then continue the search process in right subtree.
Step 7 - Repeat the same until we find the exact element or until the search element is
compared with the leaf node.
Step 8 - If we reach to the node having the value equal to the search value, then display
"Element is found" and terminate the function.
Step 9 - If we reach to the leaf node and if it is also not matched with the search element, then
display "Element is not found" and terminate the function.
Insertion Operation in AVL Tree:
Step 1 - Insert the new element into the tree using Binary Search Tree insertion logic.
Step 2 - After insertion, check the Balance Factor of every node.
Step 3 - If the Balance Factor of every node is 0 or 1 or -1 then go for next operation.
Step 4 - If the Balance Factor of any node is other than 0 or 1 or -1 then that tree is said to be
imbalanced. In this case, perform suitable Rotation to make it balanced and go for next
operation.
Eg: Construct an AVL Tree by inserting numbers from 1 to 8.

Deletion Operation in AVL Tree:
The deletion operation in AVL Tree is similar to deletion operation in BST. But after every
deletion operation, we need to check with the Balance Factor condition. If the tree is balanced
after deletion go for next operation otherwise perform suitable rotation to make the tree
Balanced.
Eg: Let's delete key sequence [6,5,4] from the below AVL tree and see how the height
balance is maintained throughout.
Delete key 6:
Delete key 5:
Delete key 4:
At this point, there is a height imbalance at node 3 with the left -left case. We do
a right rotation at node 3.

Unit 3 and 4

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit 3 and 4

Uploaded by

Copyright:

Available Formats

Unit 3

Linear Data Structures- Doubly Linked List

Doubly Linked list:

a) info – This is a field where the information has to be stored.

Pictorial representation of doubly linked list:

Operations on Double Linked List:

Inserting a node at the front end:

Step 1: Create a node:

if(first==NULL) return temp;

Step 2: Inserting into existing list:

Step 3: Return the first node:

NODE insert_front(int item, NODE first)

temp=getnode (); //obtain a node from OS

tempinfo=item; //insert an item into new node

if(first==NULL) return temp; //insert a node for the first time

temprlink=first; //insert at the beginning of existing list

return temp; //return address of new first node

Inserting a node at the rear end

Step 1: Create a node:

Step 2: Insert into empty list:

if(first==NULL) return temp;

Step 2: Find the address of last node:

Now, the pictorial representation of linked list is:

After executing the above 2 statement as:

Step 4: Return address of first node:

This can be done using statement as:

C function to insert an item at the rear end of the list:

NODE insert_front(int item, NODE first)

temp=getnode (); //obtain a node from OS

tempinfo=item; //insert an item into new node

cur=first; //get the address of first node

while(currlink!=NULL) //find address of last node

currlink=temp; //insert the node at the end

return first; //return address of the first node

Deleting a node from the front end of the list:

Step 1: List is empty:

Step 2: Delete if there is only one node:

A list having one node can be written as:

Step 3: Obtain the address of the second node:

Step 4: Make second node as first node:

It is achieved using free() function. The code can be written as:

After executing the code, list can be pictorially represented as:

Step 6: Return address of the new first node:

C function to delete an item from the front end of the list:

NODE delete_front(NODE first)

if(first==NULL) //check for empty list

printf(“List is empty cannot deleted\n”);

if(firstrlink==NULL) //delete if there is only one node

second=firstrlink; //get the address of second node

secondllink=NULL; //make second node as first node

free(first); //delete the first node

Deleting a node from rear end:

Step 1: List is empty:

A list having one node can be written as:

The last node pointed to by current can be deleted as:

printf(“item deleted=%d\n”,curinfo); //item deleted=40

prevrlink=NULL; //node pointed to by prev is the last node

Finally return address of the first node

return first; //return address of the first node

C function to delete an item from rear end of the list:

NODE delete_rear(NODE first)

NODE cur, prev;

if(first==NULL) //check for empty list

if(firstlink==NULL) //only one node is present and delete it