CENTRE FOR DISTANCE AND ONLINE EDUCATION
LAB RECORD
NAME : S.SALMAN
RRN : 242812605014
LAB : Data structures lab
CENTRE FOR DISTANCE AND ONLINE EDUCATION
DEPARTMENT OF COMPUTER APPLICATIONS
CAE 6128–Data structures Lab
(I SEMESTER)
CENTRE FOR DISTANCE AND ONLINE EDUCATION
BONAFIDE CERTIFICATE
This is a Certified Record Book of RRN: 242812605014 submitted for
the Semester End Practical Examinations held on 28-02-2025, for the
CAE 6123-Data structures Lab during 2024-2025.
---------------------------------------
Signature of LAB In-Charge
INDEX
Page
Ex.No. Date Program Title Sign
No.
1 Data Structures program to find size of the variable
Data structures program to find deallocating of the
2 memory
3 data structures program to find size of the queue
4 data structures program to find dequeue of the queue
5 data structure program to find selection sort
6 data structure program to find insertion sort
7 data structures program to find bubble sort
8 data structure program to find Binary search
9 data structure program to find Binary tree operations
10 data structures program to find BFS
11 data structures program to find DFS
12 data structure program to find Linear search
13 data structures to find post order traversal
1. Write a Data Structures program to find size of the variable
Aim
Data Structures program to find size of the variable
Program
#include<stdio.h>
int main()
{
Int intType;
Float floatType;
double doubleType;
char charType;
printf(“Size of int: %zu bytes\n”, sizeof(intType));
printf(“Size of float: %zu bytes\n”, sizeof(floatType));
printf(“Size of double: %zu bytes\n”, sizeof(doubleType));
printf(“Size of char: %zu byte\n”, sizeof(charType));
return 0;
}
Output:
Result
Thus the output is successfully complied
2.Write a data structures program to find deallocating of the memory
Aim:
Data structures program to find deallocating of the memory
Program
#include <stdio.h>
#include <stdlib.h>
int main() {
int n, i, *ptr, sum = 0;
printf("Enter number of elements: ");
scanf("%d", &n);
ptr = (int*) malloc(n * sizeof(int));
if(ptr == NULL) {
printf("Error! memory not allocated.");
exit(0);
}
printf("Enter elements: ");
for(i = 0; i < n; ++i) {
scanf("%d", ptr + i);
sum += *(ptr + i);
}
printf("Sum = %d", sum);
free(ptr);
return 0;
}
Output
Result
Thus the output is successfully complied
3 Write a data structures program to find size of the queue
Aim
Data structures program to find size of the queue
Program
#include<stdio.h>
int QUEUE[size];
int FRONT = -1;
int REAR = -1;
int i;
int is QueueEmpty()
{
if(FRONT == REAR)
return 1;
return -1;
}
Void dequeue()
{
if(isQueueEmpty() == 1)
printf(“Queue is Empty.\n”);
else
{
printf(“Dequeued element = %d\n”,QUEUE[FRONT+1]);
FRONT ++;
}
}
int isQueueFull()
{
if(REAR == size)
return 1;
return -1;
}
Void enqueue(int val)
{
If(isQueueFull() == 1)
printf(“Queue is Full\n”);
else
{
QUEUE [++REAR] = val;
REAR ++;
}
}
void displayQ()
{
for(i=0;i<= REAR;i++)
{
printf(“%d->”, QUEUE[i]);}
printf(“End of Queue\n”);
}
int main()
{
printf(“Add items 10,20 and 30\n”);
enqueue(10);
enqueue(20);
enqueue(30);
displayQ();
printf(“Front = %d, Rear = %d\n”, FRONT,REAR);
printf(“Delete two items from queue\n”);
enqueue(10);
enqueue(20);
enqueue(30);
displayQ();
printf(“Front = %d, Rear = %d\n”, FRONT,REAR);
printf(“Delete two items from queue\n”);
dequeue();
dequeue();
displayQ();
printf(“Front = %d, Rear = %d\n”, FRONT,REAR);
printf(“Add items 40,50 and 60\n”);
enqueue(40);
enqueue(50);
enqueue(60);
displayQ();
printf(“Front = %d, Rear = %d\n”, FRONT, REAR);
printf(“Delete five items from Queue\n”);
dequeue();
dequeue();
dequeue();
dequeue();
dequeue();
return 0;
}
Output
Result
Thus the output is successfully complied
4. Write a data structures program to find dequeue of the queue
Aim
Data structures program to find dequeue of the queue
Program
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *next;
};
struct node *front = NULL, *rear = NULL;
void enqueue(int val)
{
struct node *newNode = (struct node*) malloc(sizeof(struct node));
newNode->data = val;
newNode->next =NULL;
if(front == NULL && rear == NULL)
front = rear = newNode;
else
{
rear->next =newNode;
rear->newNode;
}
}
void dequeue()
{
Struct node *temp;
if(front == NULL)
printf(“Queue is Empty, unable to perform dequeue\n”);
else
{
temp->front;
front->front->next;
rear->NULL;
free(temp);
}
}
void printlist()
{
struct node *temp= front;
While(temp)
{
printf(“%d->”,temp->data);
temp = temp->next;
}
printf(“NULL\n”);
}
int main()
{
enqueue(10);
enqueue(20);
enqueue(30);
printf(“Queue :”);
printList();
dequeue();
printf(“After dequeue the new Queue :”);
dequeue();
printf(“After dequeue the new Queue :”);
printList();
return 0;
}
Output
Result
Thus the output is successfully complied
5 .Write a data structure program to find selection sort
Aim
Data structures Program to find selection sort
Program
#include<stdio.h>
#include<stdlib.h>
int * selection sort(int a[], int n)
{
int i, j, temp;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(a[i]>a[j]){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
Return a;
}
Output
Result
Thus the output is successfully complied
6. Write a data structure program to find insertion sort
Aim
Data structure program to find insertion sort
Program
#include<stdio.h>
#include<stdlib.h>
int * selection sort(int a[], int n)
{
int i, j, temp;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(a[i]>a[j]){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
Return a;
}
Int * InsertionSort(int a[], int n)
{
int i, j, temp;
for(i=1;i<n-1;i++){
temp=a[i];
j=i-1;
while((temp<a[j])&&(j>=0)){
a[j+1}=a[j];
j=j-1;
}
a[j+1]=temp;
}
Return a;
}
Output
Result
Thus the output is successfully complied
7. Write a data structures program to find bubble sort
Aim
Data structures program To find bubble sort
Program
Int * BubbleSort(int a[], int n)
{
int i, j, temp;
for(i=0;i<n-1;i++){
for(j=0;j<n-i-1;j++){
if(a[j] >a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
return a;
}
Output
Result
Thus the output is successfully complied
8. Write a data structure program to find Binary search
Aim
Data structure program to find binary search
Program
#include <stdio.h>
int main()
{
int c,first,last,middle,n,search,array[100];
printf("Enter number of elements\n");
scanf("%d",&n);
printf("Enter %d integers\n",n);
for(c=0;c<=n;c++)
scanf("%d",&array[c]);
printf("Enter value to find\n");
scanf("%d",&search);
first=0;
last=n-1;
middle=(first+last)/2;
while(first <= last){
if(array[middle] <search)
first=middle+1;
else if (array[middle]== search){
printf("%d found at the location %d\n",search,middle+1);
break;
}
else
last=middle-1;
middle=(first + last)/2;
}
if(first>last)
printf("Not found!%d isnt present in the list\n",search);
return 0;
}
}
Output
Result
Thus the output is successfully complied
9. Write a data structure program to find Binary tree operations
Aim
Data structures program to find binary tree operations
Program
#include<stdio.h>
#include<stdlib.h>
int * SelectionSort(int a[], int n) //Returns array address
{
int i, j, temp;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(a[i]>a[j]){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
return a;
}
int * InsertionSort(int a[], int n)
{
int i, j, temp;
for(i=1;i<n;i++){
temp=a[i];
j=i-1;
while((temp<a[j])&&(j>=0)){
a[j+1]=a[j];
j=j-1;
}
a[j+1]=temp;
}
return a;
}
int * BubbleSort(int a[], int n)
{
int i, j, temp;
for (i = 0 ; i < n - 1; i++)
{
for (j = 0 ; j < n - i - 1; j++)
{
if (a[j] > a[j+1]) /* For decreasing order use '<' instead of '>' */
{
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
return a;
}
int main(){
int *Sorted, i, j, count, number[25], op;
int will = 1;
printf("\t\t\tIMPLEMENTATION OF SORTING ALGORITHMS\n");
printf("\t\t\t\t***************\n");
while(will)
{
printf("Enter the array size: ");
scanf("%d",&count);
printf("Enter %d elements: ", count);
// Loop to get the elements stored in array
for(i=0;i<count;i++)
scanf("%d",&number[i]);
printf("\nWhich sort do you want to perform (select 1-3)? ");
printf("\n1. Selection Sort\n2. Insertion Sort\n3. Bubble Sort\n");
scanf("%d",&op);
switch(op){
case 1:
Sorted = SelectionSort(number,count);
printf("\nSorted Array (using Selection Sort)\n");
break;
case 2:
Sorted = InsertionSort(number,count);
printf("\nSorted Array (using Insertion Sort)\n");
break;
case 3:
Sorted = BubbleSort(number, count);
printf("\nSorted Array (using Bubble Sort)\n");
break;
default:
break;
}
printf("\n\nSorted elements: ");
for(i=0;i<count;i++)
printf(" %d",Sorted[i]);
printf("\nDo you want to try another sorting method (0/1)?");
scanf("%d",&will);
}
return 0;
}
Output
Result
Thus the output is successfully complied
10. Write a data structures to find BFS
Aim
Data structures program to find BFS
Program
#include <iostream>
#include<vector>
#include<queue>
#include<stack>
using namespace std;
//add the edge in graph
void edge(vector<int>adj[],int u,int v){
adj[u].push_back(v);
}
void bfs(int s,vector<int>adj[],bool visit[]){
queue<int>q;//queue in STL
q.push(s);
visit[s]=true;
while(!q.empty()){
int u=q.front();
cout<<u<<" ";
q.pop();
for(int i=0;i<adj[u].size();i++){
if(!visit[adj[u][i]]){
q.push(adj[u][i]);
visit[adj[u][i]]=true;
}
}
}
}
edge(adj,2,4);
cout<<"BFS traversal is"<<" ";
Output
Result
Thus the output is successfully complied
11. Write a data structures to find DFS
Aim
Data structures program to find DFS
Program
#include <iostream>
#include<vector>
#include<queue>
#include<stack>
using namespace std;
//add the edge in graph
void edge(vector<int>adj[],int u,int v){
adj[u].push_back(v);
}
void bfs(int s,vector<int>adj[],bool visit[]){
queue<int>q;//queue in STL
q.push(s);
visit[s]=true;
while(!q.empty()){
int u=q.front();
cout<<u<<" ";
q.pop();
for(int i=0;i<adj[u].size();i++){
if(!visit[adj[u][i]]){
q.push(adj[u][i]);
visit[adj[u][i]]=true;
}
}
}
}
edge(adj,2,4);
cout<<"BFS traversal is"<<" ";
void dfs(int s,vector<int>adj[],bool visit[]){
stack<int>stk;//stack in STL
stk.push(s);
visit[s]=true;
while(!stk.empty()){
int u=stk.top();
cout<<u<<" ";
stk.pop();
//loop for traverse
for(int i=0;i<adj[u].size();i++){
if(!visit[adj[u][i]]){
stk.push(adj[u][i]);
visit[adj[u][i]]=true;
}
}
}
}
int main(){
vector<int>adj[5];
bool visit[5];//array to check visit or not of a node
//initially all node are unvisited
for(int i=0;i<5;i++){
visit[i]=false;
}
//input for edges
edge(adj,0,2);
edge(adj,0,1);
edge(adj,1,3);
edge(adj,2,0);
edge(adj,2,3);
edge(adj,2,4);
cout<<"BFS traversal is"<<" ";
//call bfs funtion
bfs(0,adj,visit); //1 is a starting point
cout<<endl;
//again initialise all node unvisited for dfs
for(int i=0;i<5;i++){
visit[i]=false;
}
cout<<"DFS traversal is"<<" ";
//call dfs function
dfs(0,adj,visit);//1 is a starting point
}
Output
Result
Thus the output is successfully complied
12. Write a data structure program to find linear search
Aim
Data structures program to find linear search
Program
#include <iostream>
using namespace std;
int LinearSearch(int arr[], int low, int high, int x)
{
while (low <= high) {
int mid = low + (high - low) / 2;
// Check if x is present at mid
if (arr[mid] == x)
return mid;
// If x greater, ignore left half
if (arr[mid] < x)
low = mid + 1;
// If x is smaller, ignore right half
else
high = mid - 1;
}
return -1;
}
int main(void)
{
int arr[] = { 2, 3, 4, 10, 40 };
int x = 10;
int n = sizeof(arr) / sizeof(arr[0]);
int result = LinearSearch(arr, 0, n - 1, x);
if(result == -1) cout << "Element is not present in array";
else cout << "Element is present at index " << result;
return 0;
}
Output
Result
Thus the output is successfully complied
13. Write a data structures program to find post order traversal
Aim
Data structures program to find post order traversal
Program
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* left;
struct Node* right;
};
struct Node* createNode(int data)
{
// Allocate memory for the new node
struct Node* newNode
= (struct Node*)malloc(sizeof(struct Node));
// Initialize node data and children pointers
newNode->data = data;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}
void postorderTraversal(struct Node* root)
{
if (root != NULL) {
postorderTraversal(root->left);
postorderTraversal(root->right);
printf("%d ", root->data);
}
}
int main()
{
struct Node* root = NULL;
root = createNode(1);
root->left = createNode(2);
root->right = createNode(3);
root->left->left = createNode(4);
root->left->right = createNode(5);
root->right->left = createNode(6);
root->right->right = createNode(7);
printf("Postorder traversal of the binary tree is:\n");
postorderTraversal(root);
printf("\n");
return 0;
}
Output
Result
Thus the output is successfully complied
