Experiment:-01

Objective: Write program to implement pointers and structure in C

to understand the concepts of Dynamic memory allocation.
Code:
#include <stdio.h>
#include <stdlib.h>
struct Student {
int roll;
char name[50];
float marks;
};
int main() {
struct Student *ptr;
int n, i;
printf("==========================================\n");
printf("Name = Rajvardhan Mahajan\n");
printf("Enrollment No = 0108EC241044\n");
printf("==========================================\n");
printf("\nEnter number of students: ");
scanf("%d", &n);
ptr = (struct Student *)malloc(n * sizeof(struct Student));
if (ptr == NULL) {
printf("Memory allocation failed.\n");
return 1;
}
for (i = 0; i < n; i++) {
printf("\nEnter details for student %d:\n", i + 1);
printf("Roll number: ");
scanf("%d", &(ptr + i)->roll);
printf("Name: ");
scanf(" %[^\n]%*c", (ptr + i)->name); // Reads string with spaces
printf("Marks: ");
scanf("%f", &(ptr + i)->marks);

1
 }
printf("\n--- Student Records ---\n");
for (i = 0; i < n; i++) {
printf("\nStudent %d\n", i + 1);
printf("Roll number: %d\n", (ptr + i)->roll);
printf("Name: %s\n", (ptr + i)->name);
printf("Marks: %.2f\n", (ptr + i)->marks);
}
free(ptr);
return 0;
}
Output:

2
 Experiment:-02
Objective: Write a program to implement concept of linear array
with following operations:
i. Traverse an array.
ii. Find minimum item, maximum item, and average of an array items.
iii. Insert a new item at beginning, end and middle position within an
array.
iv. Delete an item from an array.
Code:
#include <stdio.h>
#define MAX 100

void traverse(int a[], int n) {

for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n");
}
void minMaxAvg(int a[], int n) {
int min = a[0], max = a[0], sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] < min) min = a[i];
if (a[i] > max) max = a[i];
sum += a[i];
}
printf("Min: %d\nMax: %d\nAvg: %.2f\n", min, max, (float)sum /
n);
}
int insert(int a[], int *n, int val, int pos) {
if (*n >= MAX || pos < 0 || pos > *n) return 0;
for (int i = *n; i > pos; i--) a[i] = a[i - 1];
a[pos] = val; (*n)++;
return 1;
}
int delete(int a[], int *n, int val) {
for (int i = 0; i < *n; i++) {
3
 if (a[i] == val) {
for (int j = i; j < *n - 1; j++) a[j] = a[j + 1];
(*n)--; return 1;
}
}
return 0;
}
int main() {
int a[MAX], n, ch, val;
printf("==========================================\n");
printf("Name = Rajvardhan Mahajan\n");
printf("Enrollment No = 0108EC241044\n");
printf("==========================================\n");
printf("Enter no. of elements: ");
scanf("%d", &n);
printf("Enter elements:\n");
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
while (1) {
printf("\[Link] [Link]/Max/Avg [Link] [Link] [Link]
[Link] [Link]\nChoice: ");
scanf("%d", &ch);
switch (ch) {
case 1: traverse(a, n); break;
case 2: minMaxAvg(a, n); break;
case 3: printf("Item: "); scanf("%d", &val);
insert(a, &n, val, 0) ? printf("Inserted.\n") :
printf("Fail.\n"); break;
case 4: printf("Item: "); scanf("%d", &val);
insert(a, &n, val, n) ? printf("Inserted.\n") :
printf("Fail.\n"); break;
case 5: printf("Item: "); scanf("%d", &val);
insert(a, &n, val, n/2) ? printf("Inserted.\n") :
printf("Fail.\n"); break;
case 6: printf("Item: "); scanf("%d", &val);

4
 delete(a, &n, val) ? printf("Deleted.\n") : printf("Not
found.\n"); break;
case 7: return 0;
default: printf("Invalid!\n");
}
}
}
Output:

5
 Experiment:-03
Objective: Write a program to implement singly linked list with
following operations
i. Insert a new item at beginning, end and middle position within a
single linked list.
ii. Delete an item from single linked list.
iii. Traverse a single linked list.
Code:
#include <stdio.h>
#include <stdlib.h>
struct Node { int data; struct Node* next; };
struct Node* head = NULL;
void traverse() {
struct Node* t = head;
printf("Linked List: ");
while (t) { printf("%d -> ", t->data); t = t->next; }
printf("NULL\n");
}
void insert(int val, int pos) {
struct Node* n = malloc(sizeof(struct Node)); n->data = val;
if (pos <= 1 || !head) { n->next = head; head = n; return; }
struct Node* t = head;
for (int i = 1; i < pos - 1 && t->next; i++) t = t->next;
n->next = t->next; t->next = n;
}
void insertEnd(int val) {
struct Node* n = malloc(sizeof(struct Node)); n->data = val; n->next = NULL;
if (!head) head = n;
else { struct Node* t = head; while (t->next) t = t->next; t->next = n; }
}
void delete(int val) {
struct Node *t = head, *p = NULL;
while (t && t->data != val) p = t, t = t->next;
if (!t) { printf("Item not found.\n"); return; }
if (!p) head = t->next; else p->next = t->next;

6
 free(t); printf("Item deleted.\n");
}
int main() {
int ch, val, pos;
printf("====================================\n");
printf("Name = Rajvardhan Mahajan\n");
printf("Enrollment No = 0108EC241044\n");
printf("====================================\n");
while (1) {
printf("\n1. Traverse\n2. Insert at Beginning\n3. Insert at End\n");
printf("4. Insert at Middle\n5. Delete\n6. Exit\nChoice: ");
scanf("%d", &ch);

switch (ch) {
case 1: traverse(); break;
case 2: printf("Enter value: "); scanf("%d", &val); insert(val, 1); break;
case 3: printf("Enter value: "); scanf("%d", &val); insertEnd(val); break;
case 4: printf("Enter value and position: "); scanf("%d %d", &val, &pos);
insert(val, pos); break;
case 5: printf("Enter value to delete: "); scanf("%d", &val); delete(val);
break;
case 6: return 0;
default: printf("Invalid choice.\n");
}
}
}
Output:

7
 Experiment:-04
Objective: Write a program to implement Stack with its operations
(Push, Pop, Peek, Is Empty) using:
i. Using array
ii. Using linked list
Code:
i. Stack Using Array =

#include <stdio.h>
#define MAX 100

int stack[MAX], top = -1;

void push(int val) {

if (top == MAX - 1) printf("Stack Overflow\n");
else stack[++top] = val;
}
void pop() {
if (top == -1) printf("Stack Underflow\n");
else printf("Popped: %d\n", stack[top--]);
}
void peek() {
if (top == -1) printf("Stack is Empty\n");
else printf("Top element: %d\n", stack[top]);
}
void isEmpty() {
if (top == -1) printf("Stack is Empty\n");
else printf("Stack is Not Empty\n");
}
int main() {
int ch, val;
printf("====================================\n");
printf("Name = Rajvardhan Mahajan\n");

8
 printf("Enrollment No = 0108EC241044\n");
printf("====================================\n");
while (1) {
printf("\[Link] [Link] [Link] [Link] [Link]\nChoose: ");
scanf("%d", &ch);
switch (ch) {
case 1: printf("Enter value: "); scanf("%d", &val); push(val);
break;
case 2: pop(); break;
case 3: peek(); break;
case 4: isEmpty(); break;
case 5: return 0;
default: printf("Invalid choice\n");
}
}
}
Output:

9
ii. Stack Using Linked List =

#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Node* top = NULL;
void push(int val) {
struct Node* n = malloc(sizeof(struct Node));
n->data = val;
n->next = top;
top = n;
}
void pop() {
if (!top) printf("Stack Underflow\n");
else {
printf("Popped: %d\n", top->data);
struct Node* t = top;
top = top->next;
free(t);
}
}
void peek() {
if (!top) printf("Stack is Empty\n");
else printf("Top element: %d\n", top->data);
}
void isEmpty() {
if (!top) printf("Stack is Empty\n");
else printf("Stack is Not Empty\n");
}
int main() {
int ch, val;
printf("====================================\n");

10
 printf("Name = Rajvardhan Mahajan\n");
printf("Enrollment No = 0108EC241044\n");
printf("====================================\n");
while (1) {
printf("\[Link] [Link] [Link] [Link] [Link]\nChoose: ");
scanf("%d", &ch);
switch (ch) {
case 1: printf("Enter value: "); scanf("%d", &val); push(val);
break;
case 2: pop(); break;
case 3: peek(); break;
case 4: isEmpty(); break;
case 5: return 0;
default: printf("Invalid choice\n");
}
}
}
Output:

11
 Experiment:-05
Objective: Write a program to evaluate postfix notation using stack.

Code:
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#define MAX 100
int stack[MAX];
int top = -1;
void push(int val) {
if (top >= MAX - 1) {
printf("Stack Overflow\n");
return;
}
stack[++top] = val;
}
int pop() {
if (top == -1) {
printf("Stack Underflow\n");
exit(1); // Terminate on error
}
return stack[top--];
}
int evaluatePostfix(char* exp) {
int i = 0;
while (exp[i] != '\0') {
char ch = exp[i];
if (isdigit(ch)) {
push(ch - '0'); // convert char to int
} else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
int val2 = pop();
int val1 = pop();
switch (ch) {
12
 case '+': push(val1 + val2); break;
case '-': push(val1 - val2); break;
case '*': push(val1 * val2); break;
case '/': push(val1 / val2); break;
}
}
i++;
}
return pop();
}
int main() {
char postfix[MAX];
printf("====================================\n");
printf("Name = Rajvardhan Mahajan\n");
printf("Enrollment No = 0108EC241044\n");
printf("====================================\n");
printf("Enter postfix expression (single-digit operands only): ");
scanf("%s", postfix);
int result = evaluatePostfix(postfix);
printf("Result: %d\n", result);
return 0;
}

Output:

13
 Experiment:-06
Objective: Write a program to implement binary search tree with
insert and delete operations.
Code:
#include <stdio.h>
#include <stdlib.h>
struct Node {
int d;
struct Node *l, *r;
};
struct Node* newNode(int val) {
struct Node* n = (struct Node*)malloc(sizeof(struct Node));
n->d = val; n->l = n->r = NULL;
return n;
}
struct Node* insert(struct Node* root, int val) {
if (!root) return newNode(val);
if (val < root->d) root->l = insert(root->l, val);
else root->r = insert(root->r, val);
return root;
}
struct Node* minNode(struct Node* n) {
while (n && n->l) n = n->l;
return n;
}
struct Node* del(struct Node* root, int val) {
if (!root) return root;
if (val < root->d) root->l = del(root->l, val);
else if (val > root->d) root->r = del(root->r, val);
else {
if (!root->l) { struct Node* t = root->r; free(root); return t; }
if (!root->r) { struct Node* t = root->l; free(root); return t; }
struct Node* t = minNode(root->r);
root->d = t->d;
root->r = del(root->r, t->d);
}
return root;

14
}
void in(struct Node* r) {
if (r) { in(r->l); printf("%d ", r->d); in(r->r); }
}
int main() {
struct Node* root = NULL;
int ch, v;
printf("\n=============================\n");
printf("Name = Rajvardhan Mahajan\n");
printf("Enroll= 0108EC241044\n");
printf("=============================\n");
while (1) {
printf("\[Link] [Link] [Link] [Link]\nChoice: ");
scanf("%d", &ch);
if (ch == 1) {
printf("Val: "); scanf("%d", &v);
root = insert(root, v);
} else if (ch == 2) {
printf("Val: "); scanf("%d", &v);
root = del(root, v);
} else if (ch == 3) {
in(root); printf("\n");
} else break;
}
return 0;
}
Output:

15
 Experiment:-07
Objective: Write a program to implement depth first traverse and
breadth first traverse on a graph.

Code:
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
int adj[MAX][MAX], visited[MAX], n;
void dfs(int v) {
printf("%d ", v);
visited[v] = 1;
for (int i = 0; i < n; i++)
if (adj[v][i] && !visited[i])
dfs(i);
}
void bfs(int start) {
int q[MAX], front = 0, rear = 0;
visited[start] = 1;
q[rear++] = start;
while (front < rear) {
int v = q[front++];
printf("%d ", v);
for (int i = 0; i < n; i++)
if (adj[v][i] && !visited[i]) {
visited[i] = 1;

16
 q[rear++] = i;
}
}
}
int main() {
int e, u, v, start;
printf("====================================\n");
printf("Name = Rajvardhan Mahajan\n");
printf("Enrollment No = 0108EC241044\n");
printf("====================================\n");
printf("Enter number of vertices: ");
scanf("%d", &n);
printf("Enter number of edges: ");
scanf("%d", &e);
for (int i = 0; i < e; i++) {
printf("Edge %d (u v): ", i + 1);
scanf("%d%d", &u, &v);
adj[u][v] = adj[v][u] = 1;
}
printf("\nStart vertex for DFS: ");
scanf("%d", &start);
for (int i = 0; i < n; i++) visited[i] = 0;
printf("DFS Traversal: ");
dfs(start);
printf("\n\nStart vertex for BFS: ");

17
 scanf("%d", &start);
for (int i = 0; i < n; i++) visited[i] = 0;
printf("BFS Traversal: ");
bfs(start);
return 0;
}
Output:

18
 Experiment:-08
Objective: Write program to implement linear search and binary
search on a given array.

Code:
#include <stdio.h>
void linearSearch(int a[], int n, int x) {
for (int i = 0; i < n; i++)
if (a[i] == x) { printf("Found at %d (Linear)\n", i); return; }
printf("Not found (Linear)\n");
}
void binarySearch(int a[], int n, int x) {
int l = 0, r = n - 1, m;
while (l <= r) {
m = (l + r) / 2;
if (a[m] == x) { printf("Found at %d (Binary)\n", m); return; }
else if (a[m] < x) l = m + 1;
else r = m - 1;
}
printf("Not found (Binary)\n");
}
int main() {
int a[100], n, x;
printf("====================================\n");
printf("Name = Rajvardhan Mahajan\n");
printf("Enrollment No = 0108EC241044\n");
printf("====================================\n");
printf("Enter size: "); scanf("%d", &n);
printf("Enter sorted array: ");

19
 for (int i = 0; i < n; i++) scanf("%d", &a[i]);
printf("Search item: "); scanf("%d", &x);
linearSearch(a, n, x);
binarySearch(a, n, x);
}
Output:

20
 Experiment:-09

Objective: Write a program to sort a given list of 10000 random

integers and compare their execution time using:
i. Bubble sort
ii. Insertion sort
iii. Merge sort
iv. Quick sort
v. Radix sort
Code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 10000
void copy(int *a, int *b) { for (int i = 0; i < N; i++) b[i] = a[i]; }
void bubble(int *a) {
for (int i = 0; i < N-1; i++) for (int j = 0; j < N-i-1; j++)
if (a[j] > a[j+1]) { int t = a[j]; a[j] = a[j+1]; a[j+1] = t; }
}
void insertion(int *a) {
for (int i = 1; i < N; i++) {
int key = a[i], j = i-1;
while (j >= 0 && a[j] > key) a[j+1] = a[j--];
a[j+1] = key;
}
}
void merge(int *a, int l, int m, int r) {
int i=l, j=m+1, k=0, t[r-l+1];

21
 while(i<=m && j<=r) t[k++] = a[i]<a[j] ? a[i++] : a[j++];
while(i<=m) t[k++] = a[i++]; while(j<=r) t[k++] = a[j++];
for(i=l,k=0; i<=r; i++) a[i]=t[k++];
}
void msort(int *a, int l, int r) {
if (l<r) { int m=(l+r)/2; msort(a,l,m); msort(a,m+1,r); merge(a,l,m,r);
}
}
int part(int *a, int l, int r) {
int p=a[r], i=l-1;
for (int j=l; j<r; j++) if (a[j]<p) { int t=a[++i]; a[i]=a[j]; a[j]=t; }
int t=a[i+1]; a[i+1]=a[r]; a[r]=t;
return i+1;
}
void qsort_(int *a, int l, int r) {
if (l<r) { int p=part(a,l,r); qsort_(a,l,p-1); qsort_(a,p+1,r); }
}
void radix(int *a) {
int max = a[0]; for (int i = 1; i < N; i++) if (a[i] > max) max = a[i];
for (int exp=1; max/exp>0; exp*=10) {
int out[N]={0}, cnt[10]={0};
for (int i=0;i<N;i++) cnt[(a[i]/exp)%10]++;
for (int i=1;i<10;i++) cnt[i]+=cnt[i-1];
for (int i=N-1;i>=0;i--) out[--cnt[(a[i]/exp)%10]] = a[i];
for (int i=0;i<N;i++) a[i]=out[i];
}
}
void timer(void (*sort)(int*), int *base, char *name) {
int a[N]; copy(base,a);

22
 clock_t s=clock(); sort(a); printf("%s Sort: %.3f sec\n", name,
(double)(clock()-s)/CLOCKS_PER_SEC);
}
int main() {
int base[N];
for (int i = 0; i < N; i++) base[i] = rand() % 10000;
printf("====================================\n");
printf("Name = Rajvardhan Mahajan\n");
printf("Enrollment No = 0108EC241044\n");
printf("====================================\n");
timer(bubble, base, "Bubble");
timer(insertion, base, "Insertion");
int a1[N]; copy(base,a1);
clock_t s1 = clock(); msort(a1, 0, N-1);
printf("Merge Sort: %.3f sec\n", (double)(clock()-
s1)/CLOCKS_PER_SEC);
int a2[N]; copy(base,a2);
clock_t s2 = clock(); qsort_(a2, 0, N-1);
printf("Quick Sort: %.3f sec\n", (double)(clock()-
s2)/CLOCKS_PER_SEC);
timer(radix, base, "Radix");
return 0;
}
Output:

23