LAB MANUAL

Data Structure and

Algorithms

CS 201

Faculty of Science & Technology

BS-CS
 Table of contents
S.NO TITLE Teacher
.
Sign.
01 1. Data Structure
2. Array
3. Linked list
4. Stack
5. Tree
6. Graph
02 1. Algorithm
2. Characteristics of Algorithm
3. How to write an Algorithm?
4. Algorithm Analysis
5. Algorithm Complexity
03 INSERTION SORT
04 SELECTION SORT
05 MERGE SORT
06 QUICK SORT
07 STACKS
08 QUEUES
09
10
11
12
 Lab Session 01
INTRODUCTION TO DATA
STRUCTURE

1. : DATA STRUCTURE.
1.1: WHAT IS DATA STRUCTURE?
A data structure is a systematic way of organizing and
accessing data
A data structure tries to structure data

 Usually more than one piece of data

 Should define legal operations on the data
 The data might be grouped together (e.g. in an
linked list)
When we define a data structure we are in fact creating a new
data type of our own i.e.
using predefined types or previously user defined types
Such new types are then used to reference variables type
within a program
1.2: WHY DATA STRUCTURES?

1. Data structures study how data are stored in a computer so

that operations can be implemented efficiently
2. Data structures are especially important when you have a
large amount of information
3. Conceptual and concrete ways to organize data for efficient
storage and manipulation
1.3: FOUR FUNDAMENTAL DATA STRUCTURES
The following four data structures are used ubiquitously in the
description of algorithms and serve as basic building blocks
for realizing more complex data structures.
• Sequences (also called as lists)
• Dictionaries
• Priority
• Graphs
Dictionaries and priority queues can be classified under a
broader category
called dynamic sets. Also, binary and general trees are very
popular building blocks for implementing dictionaries and
priority queues.

1.4: ARRAY

In computer programming, a group of homogeneous elements

of a specific data type is known as an array , one of the
simplest data structures. Arrays hold a series of data elements,
usually of the same size and data type. Individual elements are
accessed by their position in the array. The position is given
by an index, which is also called a subscript. The index
usually uses a consecutive range of integers, (as opposed to an
associative array) but the index can have any ordinal set of
values
Some arrays are multi-dimensional , meaning they are
indexed by a fixed number of integers, for example by a tuple
of four integers. Generally, one- and two-dimensional arrays
are the most common. Most programming languages have a
built-in array data type
  

1.5: LINK LIST

In computer science, a linked list is one of the fundamental
data structures used in computer programming. It consists of a
sequence of nodes, each containing arbitrary data fields and
one or two references ("links") pointing to the next and/or
previous nodes. A linked list is a self-referential data type
because it contains a link to another data of the same type.
Linked lists permit insertion and removal of nodes at any
point in the list in constant time, but do not allow random
access

TYPES OF LINK LIST

1. Linearly-linked List
o Singly-linked list
o Doubly-linked list
2. Circularly-linked list
o Singly-circularly-linked list
o Doubly-circularly-linked list
3. Sentinel nodes
1.6: STACK
A stack is a linear Structure in which item may be added or
removed only at one end. There are certain frequent situations
in computer science when one wants to restrict insertions and
deletions so that they can take place only at the beginning or
the end of the end of the list, not in the middle. Two of the
Data Structures that are useful in such situations
are Stacks and queues. A stack is a list of elements in which
an elements may be inserted or deleted only at one end, called
the Top. This means, in particular, the elements are removed
from a stack in the reverse order of that which they are
inserted in to the stack. The stack also called "last-in first
-out (LIFO) " list
Special terminology is used for two basic operation associated
with stack :
1. "Push" is the term used to insert an element into a stack.
2. "Pop" is the term used to delete an element from a stack.

1.7: QUEUE

A queue is a linear list of elements in which deletions can take

place only at one end, called the " front " and insertion can
take place only at the other end, called " rear ". The term
" front " and " rear " are used in describing a linear list only
when it is implemented as a queue
Queues are also called " first-in first-out " (FIFO) list. Since
the first element in a queue will be the first element out of the
queue. In other words, the order in which elements enter in a
queue is the order in which they leave. The real life example:
the people waiting in a line at Railway ticket Counter form a
queue, where the first person in a line is the first person to be
waited on. An important example of a queue in computer
science occurs in timesharing system, in which programs with
the same priority form a queue while waiting to be executed

1.8: TREE:
Data frequently contain a hierarchical relationship between
various elements. This non-linear Data structure which
reflects this relationship is called a rooted tree graph or, tree
This structure is mainly used to represent data containing a
hierarchical relationship between elements, e.g. record, family
tree and table of contents
A tree consist of a distinguished node r , called the root and
zero or more (sub) tree t1 , t2 , ... tn , each of whose roots are
connected by a directed edge to r 
In the tree of figure, the root is A, Node t 2 has r as a parent
and t 2.1 , t 2.2 and t 2.3 as children. Each node may have
arbitrary number of children, possibly zero. Nodes with no
children are known as leaves

1.9: Graph
A graph consists of a set of nodes (or Vertices ) and a set
of arc (or edge ). Each arc in a graph is specified by a pair of
nodes. A node n is incident to an arc x if n is one of the two
nodes in the ordered pair of nodes that constitute x.
The degree of a node is the number of arcs incident to it.
The indegree of a node n is the number of arcs that have n as
the head, and the outdegree of n is the number of arcs that
have n as the tail
The graph is the nonlinear data structure. The graph shown in
the figure represents 7 vertices and 12 edges. The Vertices are
{ 1, 2, 3, 4, 5, 6, 7} and the arcs are {(1,2), (1,3), (1,4), (2,4),
(2,5), (3,4), (3,6), (4,5), (4,6), (4,7), (5,7), (6,7) }. Node (4) in
figure has indegree 3, outdegree 3 and degree 6
 Lab Session 02
ALGORITHM
2: ALGORITHMS BASICS:
Algorithm is a step-by-step procedure, which defines a set of
instructions to be executed in a certain order to get the
desired output. Algorithms are generally created independent
of underlying languages, i.e. an algorithm can be
implemented in more than one programming language.
From the data structure point of view, following are some
important categories of algorithms −
 Search − Algorithm to search an item in a data structure.
 Sort − Algorithm to sort items in a certain order.
 Insert − Algorithm to insert item in a data structure.
 Update − Algorithm to update an existing item in a data
structure.
 Delete − Algorithm to delete an existing item from a
data structure.
2. 1: CHARACTERISTICS OF AN ALGORITHM
Not all procedures can be called an algorithm. An algorithm
should have the following characteristics −
 Unambiguous − Algorithm should be clear and
unambiguous. Each of its steps (or phases), and their
inputs/outputs should be clear and must lead to only one
meaning.
 Input − An algorithm should have 0 or more well-
defined inputs.
 Output − An algorithm should have 1 or more well-
defined outputs, and should match the desired output.
  Finiteness − Algorithms must terminate after a finite
number of steps.
 Feasibility − Should be feasible with the available
resources.
 Independent − An algorithm should have step-by-step
directions, which should be independent of any
programming code.
2.2 : HOW TO WRITE AN ALGORITHM?
There are no well-defined standards for writing algorithms.
Rather, it is problem and resource dependent. Algorithms are
never written to support a particular programming code.
As we know that all programming languages share basic code
constructs like loops (do, for, while), flow-control (if-else),
etc. These common constructs can be used to write an
algorithm.
We write algorithms in a step-by-step manner, but it is not
always the case. Algorithm writing is a process and is
executed after the problem domain is well-defined. That is,
we should know the problem domain, for which we are
designing a solution.
Example
Let's try to learn algorithm-writing by using an example.
Problem − Design an algorithm to add two numbers and
display the result.
Step 1 − START
Step 2 − declare three integers a, b & c
Step 3 − define values of a & b
Step 4 − add values of a & b
Step 5 − store output of step 4 to c
Step 6 − print c
Step 7 − STOP
Algorithms tell the programmers how to code the program.
Alternatively, the algorithm can be written as −
Step 1 − START ADD
Step 2 − get values of a & b
Step 3 − c ← a + b
Step 4 − display c
Step 5 − STOP
In design and analysis of algorithms, usually the second
method is used to describe an algorithm. It makes it easy for
the analyst to analyse the algorithm ignoring all unwanted
definitions. He can observe what operations are being used
and how the process is flowing.
Writing step numbers, is optional.
We design an algorithm to get a solution of a given problem.

A problem can be solved in more than one ways.

Hence, many solution algorithms can be derived for a given
problem. The next step is to analyse those proposed solution
algorithms and implement the best suitable solution.
2.3 :ALGORITHM ANALYSIS
Efficiency of an algorithm can be analysed at two different
stages, before implementation and after implementation.
They are the following −
 A Priori Analysis − This is a theoretical analysis of an
algorithm. Efficiency of an algorithm is measured by
assuming that all other factors, for example, processor
speed, are constant and have no effect on the
implementation.
 A Posterior Analysis − This is an empirical analysis of
an algorithm. The selected algorithm is implemented
using programming language. This is then executed on
target computer machine. In this analysis, actual
statistics like running time and space required, are
collected.
We shall learn about a priori algorithm analysis. Algorithm
analysis deals with the execution or running time of various
operations involved. The running time of an operation can be
defined as the number of computer instructions executed per
operation.
2.4 : ALGORITHM COMPLEXITY
Suppose X is an algorithm and n is the size of input data, the
time and space used by the algorithm X are the two main
factors, which decide the efficiency of X.
 Time Factor − Time is measured by counting the
number of key operations such as comparisons in the
sorting algorithm.
 Space Factor − Space is measured by counting the
maximum memory space required by the algorithm.
The complexity of an algorithm f(n) gives the running time
and/or the storage space required by the algorithm in terms
of n as the size of input data.
2.4.1 :SPACE COMPLEXITY
Space complexity of an algorithm represents the amount of
memory space required by the algorithm in its life cycle. The
space required by an algorithm is equal to the sum of the
following two components −
 A fixed part that is a space required to store certain data
and variables, that are independent of the size of the
problem. For example, simple variables and constants
used, program size, etc.
 A variable part is a space required by variables, whose
size depends on the size of the problem. For example,
dynamic memory allocation, recursion stack space, etc.
Space complexity S(P) of any algorithm P is S(P) = C +
SP(I), where C is the fixed part and S(I) is the variable part of
the algorithm, which depends on instance characteristic I.
Following is a simple example that tries to explain the
concept −
Algorithm: SUM(A, B)
Step 1 - START
Step 2 - C ← A + B + 10
Step 3 - Stop
Here we have three variables A, B, and C and one constant.
Hence S(P) = 1 + 3. Now, space depends on data types of
given variables and constant types and it will be multiplied
accordingly.
2.4.2 : TIME COMPLEXITY
Time complexity of an algorithm represents the amount of
time required by the algorithm to run to completion. Time
requirements can be defined as a numerical function T(n),
where T(n) can be measured as the number of steps, provided
each step consumes constant time.
For example, addition of two n-bit integers takes n steps.
Consequently, the total computational time is T(n) = c ∗ n,
where c is the time taken for the addition of two bits. Here,
we observe that T(n) grows linearly as the input size
increases.
 Lab Session 03
INSERTION SORTING
OBJECT:
To arrange the numbers in ascending order using insertion sort.
THEORY:
Insertion sort is a simple sorting algorithm that builds the final sorted
array (or list) one item at a time. It is much less efficient on large lists
than more advanced algorithms such as quicksort, heapsort, or merge
sort. However, insertion sort provides several advantages:

 Simple implementation: Jon Bentley shows a three-

line C version, and a five-line optimized version[2]
 Efficient for (quite) small data sets, much like other quadratic
sorting algorithms
 More efficient in practice than most other simple quadratic
(i.e., O(n2)) algorithms such as selection sort or bubble sort
 Adaptive, i.e., efficient for data sets that are already
substantially sorted: the time complexity is O(kn) when each
element in the input is no more than k places away from its sorted
position
 Stable; i.e., does not change the relative order of elements with
equal keys
 In-place; i.e., only requires a constant amount O(1) of additional
memory space
 Online; i.e., can sort a list as it receives it

How Insertion Sort Works?

Following are the steps involved in insertion sort:
1. We start by making the second element of the given array, i.e.
element at index 1, the key. The key element here is the new card
that we need to add to our existing sorted set of cards (remember
the example with cards above).
2. We compare the key element with the element(s) before it, in
this case, element at index 0:
o If the key element is less than the first element, we insert
the key element before the first element.
o If the key element is greater than the first element, then we
insert it after the first element.
3. Then, we make the third element of the array as key and will
compare it with elements to its left and insert it at the right
position.
4. And we go on repeating this, until the array is sorted.

ALGORITHM
Step 1: Initialize the variables i,j,n, curr and temp.
Step 2: Get the number of elements.
Step 3: Get the numbers to be sorted.
Step 4: If the second element is less than the first element then
assign it to temp.
Step 5: Assign the first element to second element.
Step 6: Assign Temp to first element.
Step 7: The swapping is done
Step 8: The data is sorted.
PROGRAM
#include<stdio.h>
#include<conio.h>
voidinsertion_sort(int a[]);
void main()
{intarr[10],i;
printf("Enter the elements of the array");
for(i=0;i<10;i++)
{
scanf("%d",&arr[i]);
}
insertion_sort(arr);
getch();
}
voidinsertion_sort(int a[])
{
intk,j,temp,n;
n=10;
for(k=1;k<=(n-1);k++)
{
temp=a[k];
j=k-1;
while(temp<=a[j] && j>=0)
{
a[j+1]=a[j];
j=j-1;
}
a[j+1]=temp;
}
printf("sorted array is:");
for(k=0;k<10;k++)
{ printf("%d\n",a[k]);
}
OUTPUT:
STUDENT’S WORK:
RESULT:
The elements were successfully arranged in ascending order using
insertion sort

Lab Session 03
SELECTION SORT
OBJECT:
To arrange the numbers in ascending order using selection sort.
THEORY:
Selection sort is a simple sorting algorithm. This sorting
algorithm is an in-place comparison-based algorithm in
which the list is divided into two parts, the sorted part at the
left end and the unsorted part at the right end. Initially, the
sorted part is empty and the unsorted part is the entire list.
The smallest element is selected from the unsorted array and
swapped with the leftmost element, and that element becomes
a part of the sorted array. This process continues moving
unsorted array boundary by one element to the right.
This algorithm is not suitable for large data sets as its average
and worst case complexities are of Ο(n 2), where n is the
number of items.

DEFINITION:
Selection sort is a simple sorting algorithm. This sorting
algorithm is an in-place comparison-based algorithm in
which the list is divided into two parts, the sorted part at the
left end and the unsorted part at the right end. Initially, the
sorted part is empty and the unsorted part is the entire list.
The smallest element is selected from the unsorted array and
swapped with the leftmost element, and that element becomes
a part of the sorted array. This process continues moving
unsorted array boundary by one element to the right.
This algorithm is not suitable for large data sets as its average
and worst case complexities are of Ο(n 2), where n is the
number of items
HOW SELECTION SORT WORKS?
Consider the following depicted array as an example.

For the first position in the sorted list, the whole list is
scanned sequentially. The first position where 14 is stored
presently, we search the whole list and find that 10 is the
lowest value.

So we replace 14 with 10. After one iteration 10, which

happens to be the minimum value in the list, appears in the
first position of the sorted list.

For the second position, where 33 is residing, we start

scanning the rest of the list in a linear manner.

We find that 14 is the second lowest value in the list and it

should appear at the second place. We swap these values.

After two iterations, two least values are positioned at the

beginning in a sorted manner.

The same process is applied to the rest of the items in the

array.
Following is a pictorial depiction of the entire sorting process
−
ALGORITHM:
Step 1: Initialize the integer variables.
Step 2: Get the total number of values from the user.
Step 3: Get the numbers to be sorted.
Step 4: Initialize i to current
Step 5: If current is less than j ,then initialize j to current.
Step 6: Assign j to temp, current to i and temp to current for
swapping
Step 7: print the sorted data
PROGRAM:
#include<stdio.h>
#include<conio.h>
int smallest(intarr[],intk,int n)
{
intsmall,j,pos;
small=arr[k];
pos=k;
for(j=k+1;j<n;j++)
{
if(small>arr[j])
{
small=arr[j];
pos=j;}}
returnpos;
}
void main()
{
inti,arr[6],k,c,temp;
clrscr();
printf("Enter 6 numbers: ");
for(i=0;i<6;i++)
{
scanf("%d",&arr[i]);
}
for(i=0;i<6;i++)
{
c=smallest(arr,i,6);
temp=arr[i];
arr[i]=arr[c];
arr[c]=temp;
}
for(i=0;i<6;i++)
{
printf("%d ",arr[i]);}
getch();
}
OUTPUT:

STUDENT’S WORK:

RESULT:
The elements were successfully arranged in ascending order using
selection sort.
 Lab Session 04
MERGE SORT
OBJECT:
To sort the given elements using Merge sort.
THEORY:
Merge sort is a sorting technique based on divide and conquer
technique. With worst-case time complexity being Ο(n log n), it is
one of the most respected algorithms.
Merge sort first divides the array into equal halves and then combines
them in a sorted manner.
HOW MERGE SORT WORKS?
To understand merge sort, we take an unsorted array as the following
−

We know that merge sort first divides the whole array iteratively into
equal halves unless the atomic values are achieved. We see here that
an array of 8 items is divided into two arrays of size 4.

This does not change the sequence of appearance of items in the

original. Now we divide these two arrays into halves.

We further divide these arrays and we achieve atomic value which

can no more be divided.

Now, we combine them in exactly the same manner as they were

broken down. Please note the color codes given to these lists.
We first compare the element for each list and then combine them
into another list in a sorted manner. We see that 14 and 33 are in
sorted positions. We compare 27 and 10 and in the target list of 2
values we put 10 first, followed by 27. We change the order of 19
and 35 whereas 42 and 44 are placed sequentially.

In the next iteration of the combining phase, we compare lists of two

data values, and merge them into a list of found data values placing
all in a sorted order.

After the final merging, the list should look like this −

ALGORITHM:
Step 1: Initialize the variables i,j,n,h,k,low,high.
Step 2: Get the number of elements.
Step 3: Get the numbers to be sorted.
Step 4: If low is less than high then find the mid value.
Step 5: Initialize h and i to low.
Step 6: Initialize a[h] to b[i] else a[j] to b[i].
Step 7: If h is greater than mid then a[k] == b[i] else b[k] ==
a[k]
Step 8 The data is sorted and printed.
PROGRAM:
#include<stdio.h>
#include<conio.h>
intarr[10];
voidmerge_sort(intarr[],int beg, int end);
void merge(int a[],intbeg,intmid,int end);
void main()
{
inti;
clrscr();
printf("Enter the array");
for(i=0;i<10;i++)
{
scanf("%d",&arr[i]);
}
merge_sort(arr,0,9);
printf("array");
for(i=0;i<10;i++)
{
printf("%d",&arr[i]);
}
getch();
}
voidmerge_sort(intarr[],intbeg,int end)
{inti;
if(beg<end)
{int mid=(beg+end)/2;
merge_sort(arr,beg,mid);
merge_sort(arr,mid+1,end);
merge(arr,beg,mid,end);
}}
void merge(intarr[],intbeg,intmid,int end)
{inti,j,index,temp[10];
i=beg;
j=mid+1;
index=beg;
while(i<=mid && j<=end)
{if(arr[i]<arr[j])
{temp[index]=arr[i];
i=i+1;
}
else
{temp[index]=arr[j];
j=j+1;
}
index=index+1;
}
if(i>mid)
{ while(j<=end)
{ temp[index]=arr[j];
index=index+1;
j=j+1;
}}
Else
{ while(i<=mid)
{temp[index]=arr[i];
index=index+1;
i=i+1;
}}
for(i=beg;i<index;i++)
{ arr[i]=temp[i];
}}
OUTPUT:

STUDENT’S WORK:

RESULT:
Hence the program for Sorting an array using merge sort was
successfully executed
 Lab Session 05
QUICK SORT
OBJECT:
To sort the given elements using Quick sort.
THEORY:
Quick sort is a highly efficient sorting algorithm and is based
on partitioning of array of data into smaller arrays. A large
array is partitioned into two arrays one of which holds values
smaller than the specified value, say pivot, based on which
the partition is made and another array holds values greater
than the pivot value.
Quick sort partitions an array and then calls itself recursively
twice to sort the two resulting subarrays. This algorithm is
quite efficient for large-sized data sets as its average and
worst case complexity are of Ο(n2), where n is the number of
items.
ALGORITHM:
Step 1: Initialize the variables i,j,n,r,p,q.
Step 2: Get the number of elements.
Step 3: Get the numbers to be sorted.
Step 4: If p is less than q then the function is called.
Step 5: If i is less than j, then interchange them.
Step 6: If I is less than pivort interchange them.
Step 7: The data is sorted and printed.

PROGRAM:
#include<stdio.h>
#include<conio.h>
int part(int a[],intbeg,intend,intloc);
void quicksort(int a[],intbeg,int end);
int a[10];
void main()
{inti;
printf("enter the array");
for(i=0;i<10;i++)
{ scanf("%d",&a[i]);
}
quicksort(a,0,9);
printf("sorted");
for(i=0;i<10;i++)
{ printf("%d\n",a[i]);
}
getch();
}
void quicksort(int a[],intbeg,int end)
{ intloc=beg;
if(beg<end)
{if(loc==beg)
{loc= part(a,beg,end,loc);
}
quicksort(a,beg,loc-1);
quicksort(a,loc+1,end);
}}
int part(int a[],intbeg,intend,intloc)
{intleft,temp,right,flag,i;
left=beg;
right=end;
loc=beg;
flag=0;
while(flag==0)
{ while((a[loc]<=a[right]) &&loc!=right)
{ right=right-1;
}
if(loc==right)
{ flag=1;
}
else if(a[loc]>a[right])
{ temp= a[loc];
a[loc]=a[right];
a[right]=temp;
loc=right;
}
if(flag==0)
{ while((a[loc]>=a[left]) &&loc!=left)
{ left=left+1;
}}
if(loc==left)
{ flag=1;
}
else if(a[loc]<a[left])
{ temp=a[loc];
a[loc]=a[left];
a[left]=temp;
loc=left;
}}
returnloc;
}
OUTPUT:

STUDENT’S WORK:

RESULT:
Hence the program for Sorting an array using quick sort was successfully
executed.
 Lab Session 06
STACKS
OBJECT:
To write a menu driven program to perform following operations on
the stack-
(i)Push (ii)Pop (iii) Peek
THEORY:
A stack is an Abstract Data Type (ADT), commonly used in
most programming languages. It is named stack as it behaves
like a real-world stack, for example – a deck of cards or a pile
of plates, etc.
A real-world stack allows operations at one end only. For
example, we can place or remove a card or plate from the top
of the stack only. Likewise, Stack ADT allows all data
operations at one end only. At any given time, we can only
access the top element of a stack.
This feature makes it LIFO data structure. LIFO stands for
Last-in-first-out. Here, the element which is placed (inserted
or added) last, is accessed first. In stack terminology,
insertion operation is called PUSH operation and removal
operation is called POP operation.

ALGORITHM:
Step 1: Initialize the integer variables.
Step 2: In a switch case, in case 1 the number to be pushed is
got
Step 3:Top is now equal to top+1
Step 4: Else the stack is full
Step 5: In case 2 the number to be deleted is got
Step 6: Top is now equal to top-1
Step 7: Else the stack is empty
Step 8: In case 3 if the top is less than 0 the stack is full
Step 9: Else the stack is printed
Step 10: Default is no such choice
PROGRAM:
#include<stdio.h>
#include<conio.h>
int a[5];int max=4;int top=-1;
void pop();void push();
void peek(); voiddisp();
void main()
{ intj,k;
charch;
clrscr();
do
{ printf("\n1push\n2)pop\n3)peek\n4)Display Stack") ;
scanf("%d",&j) ;
switch(j)
{
case 1: push();break;
case 2: pop();break;
case 3: peek();break;
case 4: disp();break;
default: printf("\ninvalid choice"); }
printf("\nDo you want to continue? (y/n)");
scanf("%s",&ch);
}while(ch=='y');
getch(); }
void push()
{ intval;
if(top==max)
printf("\nstack overflow\n");
else
{ top++;
printf("\nEnter the element");
scanf("%d",&val);
a[top]=val;}}
void pop()
{ intval;
if(top==-1)
printf("\nstack underflow\n");
else
{ val=a[top];
top--;
printf("deleted element %d", val);
}}
void peek(int a[],int top)
{ if(top==-1)
printf("empty stack\n");
else
printf("%d",a[top]);
}
voiddisp()
{ printf("Elemnts of stack are\n");
for(k=0;k<=top;k++)
{
printf("%d",a[k]);
}}
OUTPUT:

STUDENT’S WORK:

RESULT:
Hence the program for implementing stack operations like push,pop
and peek were successfully executed.
 Lab Session 06
QUEUES
OBJECT:
To perform queue operations on the menu-
(i)Insert (ii)Delete (iii)Peek (iv)Display

THEORY:
Queue is an abstract data structure, somewhat similar to
Stacks. Unlike stacks, a queue is open at both its ends. One
end is always used to insert data (enqueuer) and the other is
used to remove data (dequeuer). Queue follows First-In-First-
Out methodology, i.e., the data item stored first will be
accessed first.
QUEUE REPRESENTATION:
As we now understand that in queue, we access both ends for
different reasons. The following diagram given below tries to
explain queue representation as data structure.

As in stacks, a queue can also be implemented using Arrays,

Linked-lists, Pointers and Structures. For the sake of
simplicity, we shall implement queues using one-dimensional
array.
ALGORITHM:
Step 1: Initialize the integer variables
Step 2: In a switch case in case 1 get the number to be added
in the queue
Step 3: Else the queue is full
Step 4: In case 2 get the number to be deleted from the queue
Step 5: Else the queue is full
Step 6: If tail and head are less than 0 then in case 3 the queue
is full
Step 7: Else the queue is printed
Step 8: The default case is no such choice
PROGRAM:
#include<stdio.h>
#include<conio.h>
int a[5]; int rear=-1;
int front=-1;int max=5;
void delete(); void insert();void peek();
void main()
{intj,k;
charch;
clrscr();
do{
printf("\n1)Insert\n2)Delete\n3)Peek\n4)Display Queue") ;
scanf("%d",&j) ;
switch(j)
{ case 1: insert();break;
case 2: delete();break;
case 3: peek();break;
case 4: printf("Elemnts of queue are\n");
for(k=front;k<=rear;k++)
{ printf("\n%d",a[k]);
}
break;
default: printf("\ninvalid choice");
}
printf("\nDo you want to continue? (y/n)");
scanf("%s",&ch);
}while(ch=='y');
getch();
}
void peek()
{ printf("Peek element: %d",a[front]);
}
void insert()
{ intval;
printf("\nEnter the element");
scanf("%d",&val);
if(rear==max-1)
printf("\nQueue overflow\n");
if (front==-1 && rear==-1)
front =rear=0;
else
rear++;
a[rear]=val; }
void pop()
{ intval;
if(front==-1||front>rear)
printf("\nQueue underflow \n");
else
{ front++;
val=a[front];
printf("Element Deleted");
}}
OUTPUT:

STUDENT’S WORK:

RESULT :
Hence the program for queue operations was successfully
executed.