Data Structure Lab

(ETCS-255).

Faculty Name: Dr. Shikha Gupta

Student Name: Yatan Sachdeva

Roll No: 15614803120

Semester: 3rd

Group: I8

Maharaja Agrasen Institute of Technology, PSP Area,

Sector – 22, Rohini, New Delhi – 110085

 INDEX
EXP. EXPERIMENT DATE OF DATE OF MARKS SIGNATURE
NO NAME PERFORMANCE CHECKING

1 Introduction to data
structure

2 write a program to
insert any value
entered by the user at
a particular location
in an array

3 perform binary search

on array

4 perform linear search

on array

5 write a program to
create a singly linked
list
6 write a program to
search a given
element in a singly
linked list

7 create a linked list to

insert and delete a
node

8 write a program to
implement stack
using array, push and
pop
 Implement a
9 doubly linked list
in c

implement a
circular queue
10

1 Implement a
1 queue using
singly linked list

12 Implement in
order, pre order
and post order on
binary search
tree
.
13 Implement a
stack using
singly linked
list.
14 Implement
insertion, merge,
selection sort

15 implement queue
using array

16 implement
circular linked
list

17 create and
display binary
search tree
 EXPERIMENT-1
AIM- Introduction to data structures.

Arrays: An array is a collection of similar type of data items and each

data item is called an element of the array. The data type of the element
may be any valid data type like char, int, float or double.

The elements of array share the same variable name but each one carries
a different index number known as subscript. The array can be one
dimensional, two dimensional or multidimensional.

The individual elements of the array age are:

age[0], age[1], age[2], age[3],......... age[48], age[49].

Linked List: Linked list is a linear data structure which is used to

maintain a list in the memory. It can be seen as the collection of nodes
stored at non-contiguous memory locations. Each node of the list
contains a pointer to its adjacent node.

Stack: Stack is a linear list in which insertion and deletions are allowed
only at one end, called top.

A stack is an abstract data type (ADT), can be implemented in most of

the programming languages. It is named as stack because it behaves like
a real-world stack, for example: - piles of plates or deck of cards etc.

Queue: Queue is a linear list in which elements can be inserted only at

one end called rear and deleted only at the other end called front.

It is an abstract data structure, similar to stack. Queue is opened at both

end therefore it follows First-In-First-Out (FIFO) methodology for
storing the data items.

Trees: Trees are multilevel data structures with a hierarchical

relationship among its elements known as nodes. The bottommost
nodes in the hierarchy are called leaf node while the topmost node is
called root node. Each node contains pointers to point adjacent nodes.

Tree data structure is based on the parent-child relationship among the

nodes. Each node in the tree can have more than one children except the
leaf nodes whereas each node can have at most one parent except the
root node.
 EXPERIMENT-2
AIM- Write a program to insert any value entered by the user at a
particular location in an array.

ALGORITHM-
1. Get the element to be inserted, say x
2. Then get the position at which this element is to be inserted, say
pos
3. Then shift the array elements from this position to one position
forward, and do this for all the other elements next to pos.
4. Insert the element x now at the position pos, as this is now
empty.

CODE:
OUTPUT:
 EXPERIMENT-3
AIM- Write a program to perform binary search on array

ALGORITHM-
1. Compare x with the middle element.
2. If x matches with the middle element, we return the mid index.
3. Else If x is greater than the mid element, then x can only lie in
the right half sub array after the mid element. So we recur for the
right half.
4. Else (x is smaller) recur for the left half.
CODE-
OUTPUT:
 EXPERIMENT-4
AIM- write a program to perform linear search on array

ALGORITHM-
1. Start from the leftmost element of arr[] and one by one compare
x with each element of arr[]
2. If x matches with an element, return the index.
3. If x doesn’t match with any of elements, return -1.

CODE:

OUTPUT:
 EXPERIMENT-5
AIM- Write a program to create a singly linked list

CODE:
OUTPUT:
 EXPERIMENT-6

AIM- write a program to search a given element in a singly linked

list

ALGORITHM-
1) If head is NULL, return false.
2) If head's key is same as x, return true;
3) Else return search (head->next, x)

CODE:
OUTPUT:
 EXPERIMENT-7
AIM-write a program to create a linked list to insert and delete a
node.

ALGORITHM-

1. Insert at the beginning

• Allocate memory for new node
• Store data
• Change next of new node to point to head
• Change head to point to recently created node

2. Insert at the End

• Allocate memory for new node
• Store data
• Traverse to last node
• Change next of last node to recently created node

3. Delete from beginning

Point head to the second node

4. Delete from end

• Traverse to second last element
• Change its next pointer to null
CODE:
OUTPUT:
 EXPERIMENT-8
AIM- Write a program to implement stack using array, push and
pop

CODE:
OUTPUT:
 EXPERIMENT -9

AIM: Implement a Doubly Linked List in C.

ALGORITHM:

Operations on Double Linked List

In a double linked list, we perform the following operations...

1. Insertion
2. Deletion
3. Display

Insertion
In a double linked list, the insertion operation can be performed
in three ways as follows...

1. Inserting At Beginning of the list

2. Inserting At End of the list
3. Inserting At Specific location in the list

Inserting At Beginning of the list

We can use the following steps to insert a new node at beginning
of the double linked list...

Step 1 - Create a newNode with given value and newNode

→ previous as NULL.
Step 2 - Check whether list is Empty (head == NULL)
Step 3 - If it is Empty then, assign NULLto newNode
→ next and newNode to head.
Step 4 - If it is not Empty then, assign head to newNode
 → next and newNode to head.

Inserting At End of the list

We can use the following steps to insert a new node at end of the
double linked list...

• Step 1 - Create a newNode with given value and newNode

→ next as NULL.
• Step 2 - Check whether list is Empty (head == NULL) • Step
3 - If it is Empty, then assign NULLto newNode →
previous and newNode to head.
• Step 4 - If it is not Empty, then, define a node pointer temp
and initialize with head.
• Step 5 - Keep moving the temp to its next node until it
reaches to the last node in the list (until temp → next is equal
to NULL).
• Step 6 - Assign newNode to temp → next and temp to
newNode → previous.

Inserting At Specific location in the list (After a Node)

We can use the following steps to insert a new node after a node in
the double linked list...

• Step 1 - Create a newNode with given value.

• Step 2 - Check whether list is Empty (head == NULL)
• Step 3 - If it is Empty then, assign NULL to both newNode
→ previous & newNode → next and set newNode to head.
• Step 4 - If it is not Empty then, define two node
pointers temp1 & temp2 and initialize temp1 with head.
• Step 5 - Keep moving the temp1 to its next node until it
reaches to the node after which we want to insert the
newNode (until temp1 → data is equal to location, here
location is the node value after which we want to insert the
newNode).
• Step 6 - Every time check whether temp1 is reached to the
last node. If it is reached to the last node then display 'Given
node is not found in the list!!! Insertion not possible!!!' and
 terminate the function. Otherwise move the temp1 to next
node.
Step 7 - Assign temp1 → next to temp2, newNode to temp1
→ next, temp1 to newNode → previous, temp2 to newNode
→ next and newNode to temp2 → previous.

Deletion
In a double linked list, the deletion operation can be performed in
three ways as follows...

1. Deleting from Beginning of the list

2. Deleting from End of the list
3. Deleting a Specific Node

Deleting from Beginning of the list

We can use the following steps to delete a node from beginning of
the double linked list...

• Step 1 - Check whether list is Empty (head == NULL)

• Step 2 - If it is Empty then, display 'List is Empty!!! Deletion
is not possible' and terminate the function.
• Step 3 - If it is not Empty then, define a Node pointer 'temp'
and initialize with head.
• Step 4 - Check whether list is having only one node (temp →
previous is equal to temp → next)
• Step 5 - If it is TRUE, then set head to NULL and delete
temp (Setting Empty list conditions)
• Step 6 - If it is FALSE, then assign temp → next to head,
NULL to head
→ previous and delete temp.

Deleting from End of the list

We can use the following steps to delete a node from end of the
double linked list...

• Step 1 - Check whether list is Empty (head == NULL)

• Step 2 - If it is Empty, then display 'List is Empty!!! Deletion
is not possible' and terminate the function.
• Step 3 - If it is not Empty then, define a Node pointer 'temp'
and initialize with head.
• Step 4 - Check whether list has only one Node (temp
→ previous and temp → next both are NULL)
• Step 5 - If it is TRUE, then assign NULL to head and delete
temp. And terminate from the function. (Setting Empty list
condition)
• Step 6 - If it is FALSE, then keep moving temp until it
reaches to the last node in the list. (until temp → next is
equal to NULL)
• Step 7 - Assign NULL to temp → previous → next and
delete temp.

Deleting a Specific Node from the list

We can use the following steps to delete a specific node from the
double linked list...

• Step 1 - Check whether list is Empty (head == NULL)

• Step 2 - If it is Empty then, display 'List is Empty!!! Deletion
is not possible' and terminate the function.
• Step 3 - If it is not Empty, then define a Node pointer 'temp'
and initialize with head.
• Step 4 - Keep moving the temp until it reaches to the exact
node to be deleted or to the last node.
• Step 5 - If it is reached to the last node, then display 'Given
node not found in the list! Deletion not possible!!!' and
terminate the fuction.
• Step 6 - If it is reached to the exact node which we want to
delete, then check whether list is having only one node or not
 • Step 7 - If list has only one node and that is the node which
is to be deleted then set head to NULL and delete temp
(free(temp)).
• Step 8 - If list contains multiple nodes, then check whether
temp is the first node in the list (temp == head).
• Step 9 - If temp is the first node, then move the head to the
next node (head = head → next), set head of previous to
NULL (head → previous
= NULL) and delete temp.
• Step 10 - If temp is not the first node, then check whether it
is the last node in the list (temp → next == NULL).
• Step 11 - If temp is the last node
then set
temp of previous of next to NULL (temp → previous → next
= NULL) and delete temp (free(temp)).
• Step 12 - If temp is not the first node and not the last node,
then set
temp of previous of next to temp of next (temp → previous
→ next

= temp → next), temp of next of previous to temp of

previous (temp
→ next → previous = temp → previous) and delete temp
(free(temp)).

Displaying a Double Linked List

We can use the following steps to display the elements of a double
linked list...

• Step 1 - Check whether list is Empty (head == NULL)

• Step 2 - If it is Empty, then display 'List is Empty!!!' and
terminate the function.
• Step 3 - If it is not Empty, then define a Node pointer 'temp'
and initialize with head.
• Step 4 - Display 'NULL <--- '.
 • Step 5 - Keep displaying temp → data with an arrow
(<===>) until temp reaches to the last node
Step 6 - Finally, display temp → data with arrow pointing to NULL
(temp → data ---> NULL).

CODE-
 I rave seend (temp2 n ) ;

sea rch ( ) ;

SOPt(),

update();

/oid c °eate (
)

int data;
temp (struct c eate();
node )
temp prev ;
temp next h; h p rev
temp next ;
temp; h temp;
( , data ; temp ndata;
count ;
void inse z2 ( )
void insertl() (h

(h c eate ( ) ; h tenp,
temp1 h;
c ease
void
OUTPUT:
 EXPERIMENT-10

AIM: WAP to implement a circular queue and allow user to

perform functions like addition, deletion and display through a
menu driven program.

ALGORITHM:

1. Insertion:

Step 1: IF (REAR+1)%MAX =
FRONT Write " OVERFLOW "
Goto step 4
[End OF
IF]

Step 2: IF FRONT = -1 and REAR =

-1 SET FRONT = REAR = 0
ELSE IF REAR = MAX - 1 and FRONT
! = 0 SET REAR = 0
ELSE
SET REAR = (REAR + 1)
% MAX [END OF IF]

Step 3: SET QUEUE[REAR] =

VAL Step 4: EXIT

2. Deletion:

Step 1: IF FRONT = -1
Write " UNDERFLOW "
Goto Step 4
[END of
IF]

Step 2: SET VAL = QUEUE[FRONT]

 Step 3: IF FRONT =
REAR SET FRONT =
REAR = -1 ELSE
IF FRONT = MAX
-1 SET FRONT =
0 ELSE
SET FRONT = FRONT
+ 1 [END of IF]
[END OF

IF] Step 4:

EXIT

CODE:

#include<stdi
o.h> # define
MAX 5
int
cqueue_arr[MA
X]; int front = -
1; int rear = -1;
void insert(int
item)
{
if((front == 0 && rear == MAX-1) || (front == rear+1))
{ printf("Queue
Overflow n");
return;
}
if(front == -1)
{ front
= 0;
rear =
0; }
else
{ if(rea
r ==
MAX-
1) rear
= 0; else rear = rear+1;
} cqueue_arr[rear] =
item ; } void deletion()
{ if(front == -1)
{ printf("Queue
Underflown"); return
;
}
printf("Element deleted from queue is :
%dn",cqueue_arr[front]); if(front == rear)
{ fro
nt =
-1;
rear
=-
1; } else
{ if(fron
t ==
MAX-1) front =
0; else front =
front+1;
} } void
display() {
int front_pos = front,rear_pos
= rear; if(front == -1)
{ printf("Queue
is emptyn");
return;
} printf("Queue
elements :n");
if( front_pos <=
rear_pos )
while(front_pos <=
rear_pos) { printf("%d
",cqueue_arr[front_pos
]); front_pos++; } else
{
while(front_pos <= MAX-1)
{ printf("%d
",cqueue_arr[front_pos
]) front_pos++;
}
front_pos = 0;
while(front_pos <=
rear_pos) { printf("%d
",cqueue_arr[front_pos
]); front_pos++;
}}
printf("n
"); } int
main() {
int
choice,item;
do
{
printf("HEMANT(07914802719)\
n1.I nsertion\n"); printf("2.Deletion\
n"); printf("3.Display n\n");
printf("4.Quit\n"
);
printf("Enter your choice
: ");
scanf("%d",&choice); switch(choice)
{ case 1 : printf("Input the element for
insertion in queue : "); scanf("%d",
&item); insert(ite m); break; case 2 :
deletio n(); break; case 3: display
();
break;
case 4:
break
;
defau
lt:
printf("Wrong choicen");
}
}while(choice
!=4); return 0;
}
OUTPUT:
 EXPERIMENT -11

AIM: Implement a queue using singly linked list.

ALGORITHM:

Operations
To implement queue using linked list, we need to set the following
things before implementing actual operations.

Step 1 - Include all the header files which are used in the
program. And declare all the user defined functions.
Step 2 - Define a 'Node' structure with two members data
and next.
Step 3 - Define two Node pointers 'front' and 'rear' and set
both to
NULL.
Step 4 - Implement the main method by displaying Menu of
list of operations and make suitable function calls in the
main method to perform user selected operation.

enQueue(value) - Inserting an element into the Queue

We can use the following steps to insert a new node into the
queue...

• Step 1 - Create a newNode with given value and set

'newNode → next' to NULL.
• Step 2 - Check whether queue is Empty (rear == NULL)
• Step 3 - If it is Empty then, set front = newNode and rear =
newNode.
• Step 4 - If it is Not Empty then, set rear → next = newNode
and rear = newNode.
deQueue() - Deleting an Element from Queue
We can use the following steps to delete a node from the queue...

• Step 1 - Check whether queue is Empty (front == NULL).

• Step 2 - If it is Empty, then display "Queue is Empty!!!
Deletion is not possible!!!" and terminate from the function
• Step 3 - If it is Not Empty then, define a Node pointer 'temp'
and set it to 'front'.
• Step 4 - Then set 'front = front → next' and delete 'temp'
(free(temp)).
display() - Displaying the elements of Queue
We can use the following steps to display the elements (nodes) of
a queue...

• Step 1 - Check whether queue is Empty (front == NULL).

• Step 2 - If it is Empty then, display 'Queue is Empty!!!' and
terminate the function.
• Step 3 - If it is Not Empty then, define a Node pointer 'temp'
and initialize with front.
• Step 4 - Display 'temp → data --->' and move it to the next
node.
Repeat the same until 'temp' reaches to 'rear' (temp → next !
= NULL).
• Step 5 - Finally! Display 'temp → data ---> NULL'.

CODE:
OUTPUT:
 EXPERIMENT-12

AIM: Implement inorder, preorder and postorder on binary search

tree .

ALGORITHM:

Definition: A binary tree is said to be a binary search tree if it is

the empty tree or

1. if there is a left-child, then the data in the left-child is less

than the data in the root,
2. if there is a right-child, then the data in the right-child is no
less than the data in the root, and every sub-tree is a binary
search tree. // algorithm to implement insertion operation in
BST

Insertion in Binary Search Tree:

Check whether root node is present or not(tree available or

not). If root is NULL, create root node.
If the element to be inserted is less than the element present
in the root node, traverse the left sub-tree recursively until
we reach
T->left/T->right is NULL and place the new node at T-
>left(key in new node < key in T)/T->right (key in new
node > key in T).
If the element to be inserted is greater than the element
present in root node, traverse the right sub-tree recursively
until we reach
 T->left/T->right is NULL and place the new node at T-
>left/T->right.

Algorithm for insertion in Binary Search Tree:

TreeNode insert(int data, TreeNode T) {

if T is NULL {

T = (TreeNode *)malloc(sizeof (Struct TreeNode));

 (Allocate Memory of new node and load the data into
it)

T->data = data;

T->left = NULL;

T->right = NULL;

} else if T is less than T->left {

T->left = insert(data, T->left);

(Then node needs to be inserted in left sub-tree.So,

recursively traverse left sub-tree to find the place

where the new node needs to be inserted)

} else if T is greater than T->right {

T->right = insert(data, T->right);

(Then node needs to be inserted in right sub-tree

So, recursively traverse right sub-tree to find the

place where the new node needs to be inserted.)

return T;

// algorithm for implementing the delete operation in BST

Delete operation on binary search tree is more complicated, then

add and search. Basically, in can be divided into two stages:

• search for a node to delete;

• if the node is found, run delete algorithm.

Delete algorithm in detail:

Now, let's see more detailed description of a remove
algorithm. First stage is identical to algorithm for lookup,
except we should track the parent of the current node. Second
part is trickier. There are three cases, which are described
below.
1.

Node to be deleted has no children.

2.

This case is quite simple. Algorithm sets corresponding link

of the parent to NULL and disposes the node. Example.
Remove -4 from a BST.

3.

1.

Node to be deleted has one child.

2.

It this case, node is cut from the tree and algorithm links
single child (with it's subtree) directly to the parent of the
removed node. Example. Remove 18 from a BST.

3.
 1
.
Node to be deleted has two children.

2.

This is the most complex case. To solve it, let us see

one useful BST property first. We are going to use the
idea, that the same set of values may be represented as
different binary-search trees. For example those BSTs:

3.
contains the same values {5, 19, 21, 25}. To transform first tree
into second one, we can do following:

• choose minimum element from the right subtree (19 in the

example);
• replace 5 by 19;
• hang 5 as a left child.

The same approach can be utilized to remove a node, which has

two children:

• replace value of the node to be removed with found

minimum. Now, right subtree contains a duplicate!
• apply remove to the right subtree to remove a duplicate.

CODE:
OUTPUT:
 EXPERIMENT -13

AIM: Implement a stack using singly linked list.

ALGORITHM:

Stack Operations using Linked List

To implement a stack using a linked list, we need to set the
following things before implementing actual operations.

⚫ Step 1 - Include all the header files which are used in the
program. And declare all the user defined functions.
⚫ Step 2 - Define a 'Node' structure with two members data and
next.
⚫ Step 3 - Define a Node pointer 'top' and set it to NULL.
⚫ Step 4 - Implement the main method by displaying Menu with
list of operations and make suitable function calls in the main
method.

push(value) - Inserting an element into the Stack

We can use the following steps to insert a new node into the
stack...

• Step 1 - Create a newNode with given value.

• Step 2 - Check whether stack is Empty (top == NULL)
• Step 3 - If it is Empty, then set newNode → next = NULL.
• Step 4 - If it is Not Empty, then set newNode → next = top.
• Step 5 - Finally, set top = newNode.

pop() - Deleting an Element from a Stack

We can use the following steps to delete a node from the stack...

• Step 1 - Check whether stack is Empty (top == NULL).

• Step 2 - If it is Empty, then display "Stack is Empty!!!
Deletion is not possible!!!" and terminate the function
• Step 3 - If it is Not Empty, then define a Node pointer 'temp'
and set it to 'top'.
• Step 4 - Then set 'top = top → next'.
• Step 5 - Finally, delete 'temp'. (free(temp)).
display() - Displaying stack of elements
We can use the following steps to display the elements (nodes) of
a stack...

• Step 1 - Check whether stack is Empty (top == NULL).

• Step 2 - If it is Empty, then display 'Stack is Empty!!!' and
terminate the function.
• Step 3 - If it is Not Empty, then define a Node pointer 'temp'
and initialize with top.
• Step 4 - Display 'temp → data --->' and move it to the next
node. Repeat the same until temp reaches to the first node in
the stack. (temp → next != NULL).
• Step 5 - Finally! Display 'temp → data ---> NULL'.

CODE:
OUTPUT:
 EXPERIMENT -14

AIM: Implement insertion , merge ,selection sort

ALGORITHM:

Sorting in Data Structure

Sorting is nothing but storage of data in sorted order, it

can be in ascending or descending order. The term
Sorting comes into picture with the term Searching.
There are so many things in our real life that we need to
search, like a particular record in database, roll numbers
in merit list, a particular telephone number, any
particular page in a book etc.
Sorting arranges data in a sequence which makes searching
easier. Every record which is going to be sorted will contain
one key. Based on the key the record will be sorted.
For example, suppose we have a record of students, every
such record will have the following data: Roll No. Name
Age
Here Student roll no. can be taken as key for sorting the
records in ascending or descending order. Now suppose
we have to search a Student with roll no. 15, we don't
need to search the complete record we will simply search
between the Students with roll no. 10 to 20.

Sorting Efficiency

• There are many techniques for sorting. Implementation of

particular sorting technique depends upon situation. Sorting
techniques mainly depends on two parameters.
 • First parameter is the execution time of program, which
means time taken for execution of program.
• Second is the space, which means space taken by the

program.
Type of Sorting

• Bubble Sort
• Selection Sort
• Insertion Sort
• Quick Sort
• Merge Sort
• Heap Sort
• Shell Sort
• Bucket or Radix Sort

Selection Sort

• The selection sort technique is based upon the extension of

the minimum/maximum technique.
• Selection sorting is conceptually the simplest sorting
algorithm.
• This algorithm first finds the smallest element in the array
and exchanges it with the element in the first position, then
find the second smallest element and exchange it with the
element in the second position, and continues in this way
until the entire array is sorted.
• Selection sort is a simplicity sorting algorithm. It works as
its name as it is.
Here are basic steps of selection sort algorithm:
o Find the minimum element in the list

o Swap it with the element in the first position of the

list o Repeat the steps above for all remainder

elements of the list starting at the second position.

Advantages of Selection Sort

 • It is simple and easy to implement.
• It can be used for small data sets.
• It is 60 per cent more efficient than bubble sort.

Insertion Sort

• An insertion sort is one that sorts a set of values by inserting

values into an existing sorted file.
• It is a simple sorting algorithm that builds the final sorted
array (or list) one item at a time. This algorithm is less
efficient on large lists than more advanced algorithms such
as quicksort, heapsort, or merge sort.

Advantages of Insertion Sort

The advantages of this sorting algorithm are as follows:

• It is easy to implement and efficient to use on small sets of

data.
• It can be efficiently implemented on data sets that are
already substantially sorted.
• It performs better than algorithmslike selection sort and
bubble sort. Insertion sort algorithm is simpler than shell
sort, with only a small trade-off in efficiency. It is over
twice as fast as the bubble sort and almost 40 per cent faster
than the selection sort.
• It requires less memory space (only O(1) of additional
memory space).
• It is said to be online, as it can sort a list as and when it
receives new elements.
Merge Sort

• Merge sort is a sorting technique which divides the array

into subarrays of size 2 and merge adjacent pairs.
• Merge Sort follows the rule of Divide and Conquer. But it
doesn't divide the list into two halves.
• In merge sort the unsorted list is divided into N sub lists,
each having one element, because a list of one element is
considered sorted.
• Then, it repeatedly merge these sub lists, to produce new
sorted sub lists, and at lasts one sorted list is produced.
• Merge Sort is quite fast, and has a time complexity of O(n
log n). It is also a stable sort, which means the equal
elements are ordered in the same order in the sorted list.
CODE:

a[$ ] k ey ; r , i nt si ze )

voi d bubb T e s ort ( i nt a [ , i nt n)

(a[j] a[j j)
 v oi d me r ge1 i nt a [ § , i nt T , i nt ir, i nt

i nt I emp [ s i ze ;

(a[ij a[jj/

I emp [ k a [ i ;

I emp [ k a [ q ;

k ;

l exp [ k

a[i];
a[j];

I exp [ k
 a p te up p ;

\ oi d me n ge s a at (i nt a n n [ ] , int T , i nt n , int s i ze )

int mi d ( 1 n ) ;

v oi d qu i c k s o at ( i nt a n n [ , i nt s , i nt e )
OUTPUT:
 EXPERIMENT -15
AIM- program to implement queue using array
ALGORITH –

INSERTION
• Step 1: if rear=max-1
Write overflow
Go to step
(End of if)
• Step 2 : if front =-1 and rear =-1
Set front = rear=0
Else
Set rear =rear+1
(End of if)
• Step 3 : set queue[rear]=num
• Step 4 : exit
DELETION
• Step 1: if front =-1 or front > rear
Write underflow
Else
Set val =queue[front]
Set front = front +1
[end of if]
• Step 2 :exit

CODE:
OUTPUT :
 EXPERIMENT-16
AIM: write a program to implement circular linked list

ALGORITHM :
INSERT
• Step 1 - Create a newNode with given value.
• Step 2 - Check whether list is Empty (head == NULL)
• Step 3- set head = newNode and newNode→next = head .
• Step 4 - If it is Not Empty then, define a Node pointer 'temp'
and initialize with 'head'.
• Step 5 - Keep moving the 'temp' to its next node until it
reaches to the last node (until 'temp → next == head').
• Step 6 - Set 'newNode → next =head', 'head = newNode' and
'temp → next = head'.
DELETE

• Step 1 - Check whether list is Empty (head == NULL)

• Step 2 - If it is Empty then, display 'List is Empty!!! Deletion is
not possible' and terminate the function.
• Step 3 - If it is Not Empty then, define two Node pointers
'temp1' and 'temp2' and initialize 'temp1' with head.
• Step 4 - Check whether list has only one Node (temp1 → next
== head)
• Step 5 - If it is TRUE. Then, set head = NULL and delete
temp1. And terminate from the function. (Setting Empty list
condition)
• Step 6 - If it is FALSE. Then, set 'temp2 = temp1 ' and move
temp1 to its next node. Repeat the same until temp1 reaches to
the last node in the list. (until temp1 → next == head)
• Step 7 - Set temp2 → next = head and delete temp1.
CODE :
OUTPUT:
 EXPERIMENT-17
AIM: write a program to create an display binary search tree
ALGORITHM:
1. Define Node class which has three attributes namely: data, left
and right. Here, left represents the left child of the node and
right represents the right child of the node.
2. When a node is created, data will pass to the data attribute of the
node and both left and right will be set to null.
3. Define another class which has an attribute root.
a. Root represents the root node of the tree and initializes it to
null.
insert() will insert the new value into a binary search tree:
. It checks whether root is null, which means tree is empty. New
node will become root node of tree.
a. If tree is not empty, it will compare value of new node
with root node. If value of new node is greater than root,
new node will be inserted to right subtree. Else, it will be
inserted in left subtree.
deleteNode() will delete a particular node from the tree:
. If value of node to be deleted is less than root node, search node
in left subtree. Else, search in right subtree.
a. If node is found and it has no children, then set the node to
null.
b. If node has one child then, child node will take position of
node.
c. If node has two children then, find a minimum value node
from its right subtree. This minimum value node will
replace the current node

CODE:
OUTPUT: