Vivekananda Institute of Professional Studies

(Affiliated to Guru Gobind Singh Indraprastha University)

DATA AND FILE STRUCTURES LAB.

MCA - 168

Submitted by: Submitted to :

Shubhi Gupta Dr. Indu Sahu
MCA 2-A VSIT, VIPS
Roll no: 01517704424
Q1. Perform all operations, both searches, selection sort, insertion sort, bubble sort, shell
sort on 1D array.

Linear and Binary Search

#include <stdio.h>
#define size 6

int LinSearch(int array[], int t)

{
for(int i=0; i<size;i++)
{
if(array[i]==t)
{
return i;
}
}
return -1;}

int binSearch(int array[],int t)

{
int s=0, e=size-1;
int mid=(s+e)/2;
while(s<=e)
{
int mid=(s+e)/2;
if(array[mid]==t)
{
return mid;
}
else if(array[mid]>t)
{
e=mid-1;
}
else
{
s=mid+1;
}
}
return mid;
}

int main() {

int arr[size] = {10,20,30,40,50,70};

 printf("Array is - \n");
for(int i=0; i<size;i++)
{
printf("%d ",arr[i]);}

int ans = LinSearch(arr,70);

printf("\nIndex of 70 is %d\n",ans);
printf("40 is at index %d",binSearch(arr,40));
return 0;
}

OUTPUT

Bubble Sort

void bubble(int array[])

{
for(int i=0; i<size;i++)
{
for(int j=0; j<size-i-1;j++)
{
if(array[j]>array[j+1])
{
int t = array[j];
array[j]=array[j+1];
array[j+1]=t; }
}
}
}

OUTPUT
ShellSort

void shells(int arr[]) {

for (int gap = size/2; gap > 0; gap /= 2) {
for (int i = gap; i < size; i++) {
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
arr[j] = arr[j - gap];
arr[j] = temp; }
}
}

OUTPUT

Insertion Sort

void insertion(int arr[]) {

for (int i = 1; i < size; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}

OUTPUT
Selection Sort

void selection(int arr[]) {

for (int i = 0; i < size-1; i++) {
int min = i;
for (int j = i+1; j < size; j++) {
if (arr[j] < arr[min])
min = j;
}
if (min != i) {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}

OUTPUT

Q2. On a 2D array, perform all operations - transpose, addition, multiplication.

#include <stdio.h>

void display(int mat[3][3]) {

for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%4d", mat[i][j]);
}
printf("\n");
}
}

void T(int mat[3][3], int result[3][3]) {

for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
result[j][i] = mat[i][j];
 }
}
}

void addn(int mat1[3][3], int mat2[3][3], int result[3][3]) {

for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
result[i][j] = mat1[i][j] + mat2[i][j];
}
}
}

void multpn(int mat1[3][3], int mat2[3][3], int result[3][3]) {

for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
result[i][j] = 0;
for (int k = 0; k < 3; k++) {
result[i][j] += mat1[i][k] * mat2[k][j];
}
}
}
}
int main() {
int mat1[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

int mat2[3][3] = {
{9, 8, 7},
{6, 5, 4},
{3, 2, 1}
};
//int m3[3][3];
int tp[3][3];
int summ[3][3];
int mult[3][3];

printf("Matrix 1:\n");
display(mat1);

printf("\nMatrix 2:\n");
display(mat2);

T(mat1, tp);
 printf("\nTranspose of Matrix 1:\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%4d", tp[i][j]);
}
printf("\n");
}
addn(mat1, mat2, summ);
printf("\nMatrix Addition :\n");
display(summ);

multpn(mat1, mat2, mult);

printf("\nMatrix Multiplication :\n");
display(mult);
return 0;
}
OUTPUT

Q3. Sparse Array operations - Display, transpose and addition.

#include <stdio.h>

#define MAX 10

int main() {
int matrix1[MAX][MAX] = { {0, 5, 0}, {8, 0, 0}, {0, 0, 7} };
int matrix2[MAX][MAX] = { {0, 0, 3}, {0, 6, 0}, {0, 0, 0} };
 int result[MAX][MAX] = {0};
int numRows = 3, numCols = 3;

printf("Matrix 1:\n");
for (int i = 0; i < numRows; i++) {
for (int j = 0; j < numCols; j++) {
if (matrix1[i][j] != 0) {
printf("Row: %d, Col: %d, Value: %d\n", i, j, matrix1[i][j]);
}
}
}

printf("\nMatrix 2:\n");
for (int i = 0; i < numRows; i++) {
for (int j = 0; j < numCols; j++) {
if (matrix2[i][j] != 0) {
printf("Row: %d, Col: %d, Value: %d\n", i, j, matrix2[i][j]);
}
}
}

printf("\nTransposed Matrix 1:\n");

for (int i = 0; i < numCols; i++) {
for (int j = 0; j < numRows; j++) {
if (matrix1[j][i] != 0) {
printf("Row: %d, Col: %d, Value: %d\n", i, j, matrix1[j][i]);
}
}
}

printf("\nAdding Matrix 1 and Matrix 2:\n");

for (int i = 0; i < numRows; i++) {
for (int j = 0; j < numCols; j++) {
result[i][j] = matrix1[i][j] + matrix2[i][j];
if (result[i][j] != 0) {
printf("Row: %d, Col: %d, Value: %d\n", i, j, result[i][j]);
}
}
}

return 0;
}
OUTPUT

Q4. Stack in an Array.

#include <stdio.h>
#define MAX 10
int stack[MAX];
int top = -1;

void push(int value) {

if (top >= MAX - 1) {
printf("Stack Overflow!\n");
} else {
top++;
stack[top] = value;}
}
int pop() {
if (top == -1) {
printf("Stack Underflow!\n");
return -1;
} else {
int val = stack[top];
top--;
return val;}
}
int peek() {
if (top == -1) {
printf("Stack is empty!\n");
return -1;
} else {
return stack[top];}
}
int main() {
int choice, val;
while (1) {
printf("\n--- Operations on a Stack ---\n");
printf("1. Push\n2. Pop\n3. Peek\n4.Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter value to push: "); scanf("%d", &val);
push(val);
break;
case 2:
pop();
break;
case 3:
val = peek();

if (val != -1) {
printf("Top element: %d\n", val);}
break;
case 4:
return 0;
default:
printf("Invalid choice!\n");}
}return 0;}

OUTPUT
Q5. Standard queue in an Array.

#include <stdio.h>
#define MAX 10

int queue[MAX];
int f= -1, r = -1;
void enqueue(int value) {
if (r == MAX - 1) {
printf("Queue Overflow!\n");
return;
}
if (f== -1 && r == -1) {
f= r= 0;
 } else {
r++;
}
queue[r] = value;
}
int dequeue() {
if (f == -1 || f > r) {
printf("Queue Underflow!\n");
return -1;
}
int val = queue[f];
f++;
return val;
}
int peek() {
if (f == -1 || f > r) {
printf("Queue is empty!\n");
return -1;
}
return queue[f];
}
int main() {
int choice, val;
while (1) {
printf("\n--- Operations on Queue ---\n");
printf("1. Enqueue\n2. Dequeue\n3. Peek\n4.Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter value to enqueue: ");
scanf("%d", &val);
enqueue(val);
break;
case 2:
dequeue();
break;
case 3:
val = peek();
if (val != -1) {
printf("Front element: %d\n", val); }
break;
case 4:
return 0;
break;
default:
 printf("Invalid choice!\n");}
}
return 0;}

OUTPUT

Q6. Circular queue in an Array.

#include <stdio.h>
#define SIZE 6

int queue[SIZE];
int front = -1, rear = -1;
void enqueue(int value) {
if (front == (rear + 1) % SIZE) {
printf("Queue is Full!\n");
} else {
if (front == -1) {
 front = 0;
}
rear = (rear + 1) % SIZE;
queue[rear] = value;
printf("Inserted %d\n", value);
}
}
void dequeue() {
if (front == -1) {
printf("Queue is Empty!\n");
} else {
printf("Deleted %d\n", queue[front]);
if (front == rear) {
front = rear = -1;
} else {
front = (front + 1) % SIZE;
}
}
}
void display() {
if (front == -1) {
printf("Queue is Empty!\n");
} else {
printf("Queue elements are: ");
int i = front;
while (1) {
printf("%d ", queue[i]);
if (i == rear) break;
i = (i + 1) % SIZE;
}
printf("\n");}
}
int main() {
enqueue(10);
enqueue(20);
enqueue(30);
enqueue(40);
enqueue(50);
enqueue(60);
enqueue(50);

display();
dequeue();
dequeue();
display();
enqueue(70);
 enqueue(80);
display();
return 0;}

OUTPUT

Q7. DEQUEUE- input restricted in an Array.

#include <stdio.h>
#define SIZE 5

int deque[SIZE];
int f = -1, r = -1;

int isFull() {
return (f == 0 && r == SIZE - 1) || (f == r + 1);
}
int isEmpty() {
return (f == -1);
}

void insertRear(int value) {

if (isFull()) {
printf("Deque is Full!\n");
return;
}
if (isEmpty()) {
f = r = 0;
 } else if (r == SIZE - 1) {
r = 0;
} else {
r++;
}
deque[r] = value;
printf("Inserted %d at rear\n", value);
}

void deleteFront() {
if (isEmpty()) {
printf("Deque is Empty!\n");
return;
}
printf("Deleted %d from front\n", deque[f]);
if (f == r) {
f = r = -1;
} else if (f == SIZE - 1) {
f = 0;
} else {
f++;
}
}
void deleteRear() {
if (isEmpty()) {
printf("Deque is Empty!\n");
return;
}
printf("Deleted %d from rear\n", deque[r]);
if (f == r) {
f = r = -1;
} else if (r == 0) {
r = SIZE - 1;
} else {
r--;
}
}
void display() {
if (isEmpty()) {
printf("Deque is Empty!\n");
return;
}
printf("Deque elements: ");
int i = f;
while (1) {
printf("%d ", deque[i]);
 if (i == r) break;
i = (i + 1) % SIZE;
}
printf("\n");
}
int main() {
insertRear(10);
insertRear(20);
insertRear(30);
display();

deleteFront();
display();
deleteRear();
display();

return 0;}

OUTPUT

Q8. DEQUEUE- output restricted in an Array.

#include <stdio.h>
#define SIZE 5
int deque[SIZE];
int f = -1, r = -1;

int isFull() {
return (f == 0 && r == SIZE - 1) || (f == r + 1);
}
int isEmpty() {
return (f == -1);
}
void insertRear(int value) {
if (isFull()) {
printf("Deque is Full!\n");
return;
}
if (isEmpty()) {
f = r = 0;
} else if (r == SIZE - 1) {
r = 0;
} else {
r++;
}
deque[r] = value;
printf("Inserted %d at rear\n", value);
}
void insertFront(int value) {
if (isFull()) {
printf("Deque is Full!\n");
return;
}
if (isEmpty()) {
f = r = 0;
} else if (f == 0) {
f = SIZE - 1;
} else {
f--;
}
deque[f] = value;
printf("Inserted %d at front\n", value);
}
void deleteFront() {
if (isEmpty()) {
printf("Deque is Empty!\n");
return;
}
printf("Deleted %d from front\n", deque[f]);
if (f == r) {
f = r = -1;
} else if (f == SIZE - 1) {
f = 0;
} else {
f++;
}
}
void display() {
 if (isEmpty()) {
printf("Deque is Empty!\n");
return;
}
printf("Deque elements: ");
int i = f;
while (1) {
printf("%d ", deque[i]);
if (i == r) break;
i = (i + 1) % SIZE;
}
printf("\n");
}

int main() {
insertRear(10);
insertRear(20);
insertRear(30);
display();
insertFront(5);
insertFront(1);
display();

deleteFront();
display();
return 0;
}

OUTPUT

Q9. Double stack in an Array.

#include <stdio.h>
#define SIZE 10

int arr[SIZE];
int top1 = -1; //stack1 top=-1
int top2 = SIZE; //stack2 top=size of entire array

//operations for stack 1

void push1(int value) {

if (top1 + 1 == top2) {
printf("Stack Overflow! Cannot push %d in Stack 1\n", value);
return;
}
arr[++top1] = value;
printf("Pushed %d into Stack 1\n", value);
}
int pop1() {
if (top1 == -1) {
printf("Stack 1 Underflow!\n");
return -1;
}
return arr[top1--];
}

void displayS1() {
printf("Stack 1: ");
for (int i = 0; i <= top1; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}

//stack2 operations
void push2(int value) {
if (top1 + 1 == top2) {
printf("Stack Overflow! Cannot push %d in Stack 2\n", value);
return;
}
arr[--top2] = value;
printf("Pushed %d into Stack 2\n", value);
}

int pop2() {
if (top2 == SIZE) {
printf("Stack 2 Underflow!\n");
 return -1;
}
return arr[top2++];
}
void displayS2() {
printf("Stack 2: ");
for (int i = SIZE - 1; i >= top2; i--) {
printf("%d ", arr[i]);
}
printf("\n");
}

int main() {
push1(10);
push1(20);
push1(30);
push2(100);
push2(90);
push2(80);

displayS1();
displayS2();

printf("Popped from Stack 1 : %d\n", pop1());

printf("Popped from Stack 2 : %d\n", pop2());

displayS1();
displayS2();

printf("Top of stack 1 is %d\n",arr[top1]);

printf("Top of stack 2 is %d",arr[top2]);

return 0;
}
OUTPUT

Q10. Double queue in an Array.

#include <stdio.h>
#define SIZE 5

int Dequeue[SIZE];
int f = -1, r = -1;
int isFull() {
return (f == 0 && r == SIZE - 1) || (f == r + 1);

int isEmpty() {
return (f == -1);
}
void insertFront(int value) {
if (isFull()) {
printf("Dequeue is Full!\n");
return;
}
if (isEmpty()) {
f = r = 0;
} else if (f == 0) {
f = SIZE - 1;
 } else {
f--;
}
Dequeue[f] = value;
printf("Inserted %d at front\n", value);
}

void insertRear(int value) {

if (isFull()) {
printf("Dequeueue is Full!\n");
return;
}
if (isEmpty()) {
f = r = 0;
} else if (r == SIZE - 1) {
r = 0;
} else {
r++;
}
Dequeue[r] = value;
printf("Inserted %d at rear\n", value);
}
void deleteFront() {
if (isEmpty()) {
printf("Dequeue is Empty!\n");
return;
}
printf("Deleted %d from front\n", Dequeue[f]);
if (f == r) {
f = r = -1;
} else if (f == SIZE - 1) {
f = 0;
} else {
f++;
}
}
void deleteRear() {
if (isEmpty()) {
printf("Dequeue is Empty!\n");
return;
}
printf("Deleted %d from rear\n", Dequeue[r]);
if (f == r) {
f = r = -1;
} else if (r == 0) {
r = SIZE - 1;
 } else {
r--;
}
}
void display() {
if (isEmpty()) {
printf("Dequeue is Empty!\n");
return;
}
printf("Dequeue elements: ");
int i = f;
while (1) {
printf("%d ", Dequeue[i]);
if (i == r) break;
i = (i + 1) % SIZE;
}
printf("\n");
}
int main() {
insertRear(10);
insertRear(20);
deleteRear();
insertFront(20);

insertRear(30);
display();
return 0;
}

OUTPUT

Q11. Singly linked list. operations- create, traverse, insert( front, end, by position, before
and after value ), delete( front, end, by position, by value), search, reverse.
#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* next;
};
struct Node* head = NULL;

void create(int value) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = NULL;
if (head == NULL)
head = newNode;
else {
struct Node* temp = head;
while (temp->next != NULL)
temp = temp->next;
temp->next = newNode;
}
printf("%d inserted\n", value);
}

void traverse() {
if (head == NULL) {
printf("List is empty\n");
return;
}
struct Node* temp = head;
printf("List: ");
while (temp != NULL) {
printf("%d -> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}
void insertFront(int value) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = head;
head = newNode;
printf("%d inserted at front\n", value);}
void insertEnd(int value) {
create(value);
}
void insertAtPos(int value, int pos) {
if (pos <= 0) {
printf("Invalid position\n");
return;
}

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

newNode->data = value;
if (pos == 1) {
newNode->next = head;
head = newNode;
printf("%d inserted at position %d\n", value, pos);
return;
}
struct Node* temp = head;
for (int i = 1; temp != NULL && i < pos - 1; i++)
temp = temp->next;

if (temp == NULL) {
printf("Position out of range\n");
free(newNode);
return;
}
newNode->next = temp->next;
temp->next = newNode;
printf("%d inserted at position %d\n", value, pos);
}

void insertBefore(int target, int value) {

if (head == NULL) return;
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;

if (head->data == target) {
newNode->next = head;
head = newNode;
printf("%d inserted before %d\n", value, target);
return;
}
struct Node* temp = head;
while (temp->next != NULL && temp->next->data != target)
temp = temp->next;

if (temp->next == NULL) {
 printf("Target %d not found\n", target);
free(newNode);
return;
}
newNode->next = temp->next;
temp->next = newNode;
printf("%d inserted before %d\n", value, target);
}

void insertAfter(int target, int value) {

struct Node* temp = head;
while (temp != NULL && temp->data != target)
temp = temp->next;

if (temp == NULL) {
printf("Target %d not found\n", target);
return;
}

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

newNode->data = value;
newNode->next = temp->next;
temp->next = newNode;
printf("%d inserted after %d\n", value, target);}
void deletebeg() {
if (head == NULL) {
printf("List is empty\n");
return;
}
struct Node* temp = head;
head = head->next;
printf("Deleted %d from front\n", temp->data);
free(temp);
}

void deletend() {
if (head == NULL) {
printf("List is empty\n");
return;
}
if (head->next == NULL) {
printf("Deleted %d from end\n", head->data);
free(head);
head = NULL;
return;
}
 struct Node* temp = head;
while (temp->next->next != NULL)
temp = temp->next;

printf("Deleted %d from end\n", temp->next->data);

free(temp->next);
temp->next = NULL;
}

void deleteAtPos(int pos) {

if (head == NULL || pos <= 0) {
printf("Invalid position or empty list\n");
return;
}
if (pos == 1) {
deletebeg();
return;
}
struct Node* temp = head;
for (int i = 1; temp != NULL && i < pos - 1; i++)
temp = temp->next;

if (temp == NULL || temp->next == NULL) {

printf("Position out of range\n");
return;
}
struct Node* del = temp->next;
temp->next = del->next;
printf("Deleted %d from position %d\n", del->data, pos);
free(del);
}
void deleteByValue(int value) {
if (head == NULL) return;

if (head->data == value) {
deletebeg();
return;
}
struct Node* temp = head;
while (temp->next != NULL && temp->next->data != value)
temp = temp->next;

if (temp->next == NULL) {
printf("Value %d not found\n", value);
return;
}
 struct Node* del = temp->next;
temp->next = del->next;
printf("Deleted node with value %d\n", value);
free(del);
}
void search(int value) {
int pos = 1;
struct Node* temp = head;
while (temp != NULL) {
if (temp->data == value) {
printf("Value %d found at position %d\n", value, pos);
return;
}
temp = temp->next;
pos++;
}
printf("Value %d not found\n", value);
}
void reverse() {
struct Node* prev = NULL;
struct Node* curr = head;
struct Node* next = NULL;
while (curr != NULL) {
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
head = prev;
}

int main() {
create(5);
create(10);
traverse();

insertEnd(20);
insertAtPos(25, 3);
insertAfter(25, 30);
traverse();
deletebeg();

reverse();
traverse();
return 0;
}

OUTPUT

Q12. Circular linked list with a header node.

#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* next;
};

struct Node* header = NULL;

void createHeader() {
header = (struct Node*)malloc(sizeof(struct Node));
if (header == NULL) {
printf("Memory allocation failed.\n");
exit(1);
}
header->data = -1;
header->next = header;
}
void insertEnd(int value) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
 newNode->next = header;

struct Node* temp = header;

while (temp->next != header) {
temp = temp->next;
}
temp->next = newNode;
}

void deleteNode(int value) {

struct Node* current = header->next;
struct Node* previous = header;

while (current != header) {

if (current->data == value) {
previous->next = current->next;
free(current);
printf("Deleted node with value: %d\n", value);
return;
}
previous = current;
current = current->next;
}
printf("Value %d not found in the list.\n", value);
}
void displayList() {
struct Node* temp = header->next;

if (temp == header) {
printf("List is empty.\n");
return;
}

printf("List elements: ");

while (temp != header) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}

int main() {
createHeader();
 insertEnd(10);
insertEnd(20);
insertEnd(30);
insertEnd(40);
insertEnd(50);
insertEnd(60);

printf("List before deletion:\n");

displayList();

deleteNode(30);
deleteNode(50);

printf("List after deletion:\n");

displayList();

return 0;
}

OUTPUT

Q13. Dynamic stack.

#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* next;
};
struct Node* top = NULL;

void push(int value) {

 struct Node* curptr = (struct Node*)malloc(sizeof(struct Node));
if (!curptr) {
printf("Memory allocation failed\n");
return;
}
curptr->data = value;
curptr->next = top;
top = curptr;
printf("%d pushed to stack\n", value);
}
void pop() {
if (top == NULL) {
printf("Stack Underflow\n");
return;
}
struct Node* temp = top;
printf("Popped %d\n", top->data);
top = top->next;
free(temp);
}
int peek() {
if (top == NULL) {
printf("Stack is empty\n");
}
return top->data;
}

int main() {
int choice, val;
while (1) {
printf("\n--- Operations on a Stack ---\n");
printf("1. Push\n2. Pop\n3. Peek\n4.Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter value to push: "); scanf("%d", &val);
push(val);
break;
case 2:
pop();
break;
case 3:
val = peek();
if (val != -1) {
printf("Top element: %d\n", val);}
 break;
case 4:
return 0;
default:
printf("Invalid choice!\n");}
}return 0;}

OUTPUT

Q14. Dynamic queue with sentinel nodes - header node and trailer node.

#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* next;
};

struct Node* header = NULL;

struct Node* trailer = NULL;

void createSentinels() {
header = (struct Node*)malloc(sizeof(struct Node));
trailer = (struct Node*)malloc(sizeof(struct Node));
if (header == NULL || trailer == NULL) {
printf("Memory allocation failed.\n");
exit(1);
}
header->next = trailer;
trailer->next = NULL;
}

void enqueue(int value) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = trailer;
struct Node* temp = header;

while (temp->next != trailer) {

temp = temp->next;
}
temp->next = newNode;
}
void dequeue() {
if (header->next == trailer) {
printf("Queue is empty. Cannot dequeue.\n");
return;
}
struct Node* temp = header->next;
header->next = temp->next;
printf("Dequeued value: %d\n", temp->data);
free(temp);
}
void displayQueue() {
struct Node* temp = header->next;

if (temp == trailer) {
printf("Queue is empty.\n");
return;
}
printf("Queue elements: ");
while (temp != trailer) {
 printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
int main() {
createSentinels();

enqueue(10);
enqueue(20);
enqueue(30);
enqueue(40);
enqueue(50);
enqueue(60);
printf("Queue before dequeue:\n");
displayQueue();
dequeue();
dequeue();
printf("Queue after dequeue:\n");
displayQueue();

return 0;
}

OUTPUT

Q15. Dynamic circular queue.

#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* next;
};
struct Node* front = NULL;
struct Node* rear = NULL;

void enqueue(int value) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;

if (front == NULL) {
front = rear = newNode;
rear->next = front;
} else {
rear->next = newNode;
rear = newNode;
rear->next = front;
}
}
void dequeue() {
if (front == NULL) {
printf("Queue is empty. Cannot dequeue.\n");
return;
}
int value;
if (front == rear) {
value = front->data;
free(front);
front = rear = NULL;
} else {
struct Node* temp = front;
value = temp->data;
front = front->next;
rear->next = front;
free(temp);
}

printf("Dequeued value: %d\n", value);

}
void displayQueue() {
if (front == NULL) {
printf("Queue is empty.\n");
return;
}
struct Node* temp = front;
 printf("Queue elements: ");
do {
printf("%d ", temp->data);
temp = temp->next;
} while (temp != front);
printf("\n");
}
int main() {

enqueue(10);
enqueue(20);
enqueue(30);
enqueue(40);
enqueue(50);
enqueue(60);

printf("Queue before dequeue:\n");

displayQueue();
dequeue();
dequeue();
printf("Queue after dequeue:\n");
displayQueue();

return 0;
}

OUTPUT

Q16. Doubly linked list - operations: create, traverse, insert and delete.

#include <stdio.h>
#include <stdlib.h>

struct Node {
 int data;
struct Node* prev;
struct Node* next;
};

struct Node* head = NULL;

struct Node* tail = NULL;

void createNode(int value) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = NULL;
newNode->prev = NULL;

if (head == NULL) {
head = tail = newNode;
} else {
tail->next = newNode;
newNode->prev = tail;
tail = newNode;
}
}
void traverseList() {
if (head == NULL) {
printf("List is empty.\n");
return;
}

struct Node* temp = head;

printf("Doubly Linked List: ");
while (temp != NULL) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
void insertAtPosition(int value, int position) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = NULL;
newNode->prev = NULL;

if (position == 1) {
 newNode->next = head;
if (head != NULL)
head->prev = newNode;
head = newNode;
if (tail == NULL)
tail = newNode;
return;
}

struct Node* temp = head;

int i = 1;
while (temp != NULL && i < position - 1) {
temp = temp->next;
i++;
}

if (temp == NULL) {
printf("Position out of bounds.\n");
free(newNode);
return;
}

newNode->next = temp->next;
newNode->prev = temp;

if (temp->next != NULL)
temp->next->prev = newNode;
else
tail = newNode;

temp->next = newNode;
}
void deleteAtPosition(int position) {
if (head == NULL) {
printf("List is empty. Cannot delete.\n");
return;
}

struct Node* temp = head;

if (position == 1) {
head = head->next;
if (head != NULL)
 head->prev = NULL;
else
tail = NULL;
printf("Deleted value: %d\n", temp->data);
free(temp);
return;
}

int i = 1;
while (temp != NULL && i < position) {
temp = temp->next;
i++;
}

if (temp == NULL) {
printf("Position out of bounds.\n");
return;
}

if (temp->prev != NULL)
temp->prev->next = temp->next;
if (temp->next != NULL)
temp->next->prev = temp->prev;
else
tail = temp->prev;

printf("Deleted value: %d\n", temp->data);

free(temp);
}
int main() {
createNode(10);
createNode(20);
createNode(30);
createNode(40);

printf("Initial list:\n");
traverseList();

printf("Inserting 25 at position 3:\n");

insertAtPosition(25, 3);
traverseList();

printf("Deleting node at position 2:\n");

 deleteAtPosition(2);
traverseList();

return 0;
}

OUTPUT

Q17. Polynomial arithmetic for polynomials in one variable.

#include <stdio.h>
#include <stdlib.h>

struct Term {
int coeff;
int exp;
struct Term* next;
};

struct Term* create(int coeff, int exp) {

struct Term* newTerm = (struct Term*)malloc(sizeof(struct Term));
newTerm->coeff = coeff;
newTerm->exp = exp;
newTerm->next = NULL;
return newTerm;
}

void insert(struct Term** poly, int coeff, int exp) {

struct Term* newTerm = create(coeff, exp);
if (*poly == NULL || (*poly)->exp < exp) {
newTerm->next = *poly;
*poly = newTerm;
} else {
 struct Term* temp = *poly;
while (temp->next && temp->next->exp > exp)
temp = temp->next;
if (temp->exp == exp)
temp->coeff += coeff;
else if (temp->next && temp->next->exp == exp)
temp->next->coeff += coeff;
else {
newTerm->next = temp->next;
temp->next = newTerm;
}
}
}

void display(struct Term* poly) {

while (poly) {
printf("%dx^%d", poly->coeff, poly->exp);
poly = poly->next;
if (poly) printf(" + ");
}
printf("\n");
}

struct Term* add(struct Term* a, struct Term* b) {

struct Term* result = NULL;
while (a || b) {
if (!b || (a && a->exp > b->exp)) {
insert(&result, a->coeff, a->exp);
a = a->next;
} else if (!a || (b && b->exp > a->exp)) {
insert(&result, b->coeff, b->exp);
b = b->next;
} else {
insert(&result, a->coeff + b->coeff, a->exp);
a = a->next;
b = b->next;
}
}
return result;
}

struct Term* multiply(struct Term* a, struct Term* b) {

struct Term* result = NULL;
 for (struct Term* p = a; p; p = p->next)
for (struct Term* q = b; q; q = q->next)
insert(&result, p->coeff * q->coeff, p->exp + q->exp);
return result;
}

int main() {
struct Term* poly1 = NULL;
struct Term* poly2 = NULL;

insert(&poly1, 3, 2);
insert(&poly1, 5, 1);
insert(&poly1, 6, 0);

insert(&poly2, 6, 1);
insert(&poly2, 8, 0);

printf("Poly 1: ");
display(poly1);
printf("Poly 2: ");
display(poly2);

struct Term* sum = add(poly1, poly2);

printf("Sum: ");
display(sum);

struct Term* product = multiply(poly1, poly2);

printf("Product: ");
display(product);

return 0;
}

OUTPUT

Q18. Addition of two large integers.

#include <stdio.h>
#include <string.h>

int main() {
char num1[21], num2[21], result[22];
int i, j, k = 0, carry = 0;

printf("Enter first number (up to 20 digits): ");

scanf("%s", num1);
printf("Enter second number (up to 20 digits): ");
scanf("%s", num2);

int len1 = strlen(num1);

int len2 = strlen(num2);

i = len1 - 1;
j = len2 - 1;

while (i >= 0 || j >= 0 || carry > 0) {

int digit1 = (i >= 0) ? num1[i--] - '0' : 0;
int digit2 = (j >= 0) ? num2[j--] - '0' : 0;

int sum = digit1 + digit2 + carry;

result[k++] = (sum % 10) + '0';
carry = sum / 10;
}

result[k] = '\0';

printf("Sum: ");
for (int l = k - 1; l >= 0; l--)
printf("%c", result[l]);
printf("\n");

return 0;
}
OUTPUT

Q19. Binary search tree- operations: insert, traverse recursive, traverse iterative, search

#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* left;
struct Node* right;
};

struct Node* createNode(int value) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->left = newNode->right = NULL;
return newNode;
}

struct Node* insert(struct Node* root, int value) {

if (root == NULL)
return createNode(value);
if (value < root->data)
root->left = insert(root->left, value);
else if (value > root->data)
root->right = insert(root->right, value);
return root;
}

void inorder(struct Node* root) {

if (root != NULL) {
inorder(root->left);
printf("%d ", root->data);
inorder(root->right);
 }
}

void preorder(struct Node* root) {

if (root != NULL) {
printf("%d ", root->data);
preorder(root->left);
preorder(root->right);
}
}

void postorder(struct Node* root) {

if (root != NULL) {
postorder(root->left);
postorder(root->right);
printf("%d ", root->data);
}
}

void iterativeInorder(struct Node* root) {

struct Node* stack[100];
int top = -1;
struct Node* current = root;

while (current != NULL || top != -1) {

while (current != NULL) {
stack[++top] = current;
current = current->left;
}
current = stack[top--];
printf("%d ", current->data);
current = current->right;
}
}

struct Node* search(struct Node* root, int key) {

while (root != NULL) {
if (key == root->data)
return root;
else if (key < root->data)
root = root->left;
else
root = root->right;
 }
return NULL;
}

int main() {
struct Node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 70);
insert(root, 20);
insert(root, 40);
insert(root, 60);
insert(root, 80);

printf("Recursive Inorder: ");

inorder(root);
printf("\n");

printf("Recursive Preorder: ");

preorder(root);
printf("\n");

printf("Recursive Postorder: ");

postorder(root);
printf("\n");

printf("Iterative Inorder: ");

iterativeInorder(root);
printf("\n");

int key = 60;

if (search(root, key) != NULL)
printf("Found %d in the tree.\n", key);
else
printf("%d not found in the tree.\n", key);

return 0;
}
OUTPUT

Q20. Quick sort

#include <stdio.h>

void swap(int* a, int* b) {

int temp = *a;
*a = *b;
*b = temp;
}

int partition(int arr[], int low, int high) {

int pivot = arr[high];
int i = low - 1;

for (int j = low; j < high; j++) {

if (arr[j] < pivot) {
i++;
swap(&arr[i], &arr[j]);
}
}

swap(&arr[i + 1], &arr[high]);

return i + 1;
}

void quickSort(int arr[], int low, int high) {

if (low < high) {
int pi = partition(arr, low, high);
 quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

void printArray(int arr[], int size) {

for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
int arr[100], n;

printf("Enter number of elements: ");

scanf("%d", &n);

printf("Enter %d elements:\n", n);

for (int i = 0; i < n; i++)
scanf("%d", &arr[i]);

quickSort(arr, 0, n - 1);

printf("Sorted array: ");

printArray(arr, n);

return 0;
}

OUTPUT
Q21. Merge sort

#include <stdio.h>

void merge(int arr[], int left, int mid, int right) {

int i = left, j = mid + 1, k = 0;
int temp[100];

while (i <= mid && j <= right) {

if (arr[i] < arr[j])
temp[k++] = arr[i++];
else
temp[k++] = arr[j++];
}

while (i <= mid)

temp[k++] = arr[i++];

while (j <= right)

temp[k++] = arr[j++];

for (i = left, k = 0; i <= right; i++, k++)

arr[i] = temp[k];
}

void mergeSort(int arr[], int left, int right) {

if (left < right) {
int mid = (left + right) / 2;

mergeSort(arr, left, mid);

mergeSort(arr, mid + 1, right);

merge(arr, left, mid, right);

}
}

void printArray(int arr[], int n) {

for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
 int arr[100], n;

printf("Enter number of elements: ");

scanf("%d", &n);

printf("Enter %d elements:\n", n);

for (int i = 0; i < n; i++)
scanf("%d", &arr[i]);

mergeSort(arr, 0, n - 1);

printf("Sorted array: ");

printArray(arr, n);

return 0;
}

OUTPUT

Q22. Heap sort

#include <stdio.h>

void swap(int* a, int* b) {

int temp = *a;
*a = *b;
*b = temp;
}

void heapify(int arr[], int n, int i) {

int largest = i;
int left = 2 * i + 1;
 int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest])

largest = left;

if (right < n && arr[right] > arr[largest])

largest = right;

if (largest != i) {
swap(&arr[i], &arr[largest]);
heapify(arr, n, largest);
}
}

void heapSort(int arr[], int n) {

for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);

for (int i = n - 1; i >= 0; i--) {

swap(&arr[0], &arr[i]);
heapify(arr, i, 0);
}
}

void printArray(int arr[], int size) {

for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main() {
int arr[100], n;

printf("Enter number of elements: ");

scanf("%d", &n);

printf("Enter %d elements:\n", n);

for (int i = 0; i < n; i++)
scanf("%d", &arr[i]);

heapSort(arr, n);

printf("Sorted array: ");

 printArray(arr, n);

return 0;
}

OUTPUT

Q23. BFS

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX 100

struct Queue {
int items[MAX];
int front;
int rear;
};

struct Graph {
int adjMatrix[MAX][MAX];
int numVertices;
};

void initQueue(struct Queue* q) {

q->front = -1;
q->rear = -1;
}

bool isQueueEmpty(struct Queue* q) {

return q->front == -1;
}

void enqueue(struct Queue* q, int value) {

 if (q->rear == MAX - 1) {
printf("Queue is full\n");
} else {
if (q->front == -1)
q->front = 0;
q->rear++;
q->items[q->rear] = value;
}
}

int dequeue(struct Queue* q) {

if (isQueueEmpty(q)) {
printf("Queue is empty\n");
return -1;
} else {
int item = q->items[q->front];
q->front++;
if (q->front > q->rear)
q->front = q->rear = -1;
return item;
}
}

void initGraph(struct Graph* g, int numVertices) {

g->numVertices = numVertices;
for (int i = 0; i < numVertices; i++)
for (int j = 0; j < numVertices; j++)
g->adjMatrix[i][j] = 0;
}

void addEdge(struct Graph* g, int start, int end) {

g->adjMatrix[start][end] = 1;
g->adjMatrix[end][start] = 1;
}

void bfs(struct Graph* g, int startVertex) {

bool visited[MAX] = {false};
struct Queue q;
initQueue(&q);

visited[startVertex] = true;
enqueue(&q, startVertex);
 printf("BFS starting from vertex %d: ", startVertex);

while (!isQueueEmpty(&q)) {
int currentVertex = dequeue(&q);
printf("%d ", currentVertex);

for (int i = 0; i < g->numVertices; i++) {

if (g->adjMatrix[currentVertex][i] == 1 && !visited[i]) {
visited[i] = true;
enqueue(&q, i);
}
}
}
printf("\n");
}

int main() {
struct Graph g;
int numVertices, numEdges, startVertex, start, end;

printf("Enter the number of vertices: ");

scanf("%d", &numVertices);
initGraph(&g, numVertices);

printf("Enter the number of edges: ");

scanf("%d", &numEdges);

printf("Enter the edges (start and end vertex):\n");

for (int i = 0; i < numEdges; i++) {
scanf("%d %d", &start, &end);
addEdge(&g, start, end);
}

printf("Enter the starting vertex for BFS: ");

scanf("%d", &startVertex);

bfs(&g, startVertex);

return 0;
}

OUTPUT
Q24. DFS

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX 100

struct Graph {
int adjMatrix[MAX][MAX];
int numVertices;
};

void initGraph(struct Graph* g, int numVertices) {

g->numVertices = numVertices;
for (int i = 0; i < numVertices; i++)
for (int j = 0; j < numVertices; j++)
g->adjMatrix[i][j] = 0;
}

void addEdge(struct Graph* g, int start, int end) {

g->adjMatrix[start][end] = 1;
g->adjMatrix[end][start] = 1;
}

void dfs(struct Graph* g, int vertex, bool visited[]) {

visited[vertex] = true;
printf("%d ", vertex);

for (int i = 0; i < g->numVertices; i++) {

if (g->adjMatrix[vertex][i] == 1 && !visited[i]) {
 dfs(g, i, visited);
}
}
}

int main() {
struct Graph g;
int numVertices, numEdges, startVertex, start, end;

printf("Enter the number of vertices: ");

scanf("%d", &numVertices);
initGraph(&g, numVertices);

printf("Enter the number of edges: ");

scanf("%d", &numEdges);

printf("Enter the edges (start and end vertex):\n");

for (int i = 0; i < numEdges; i++) {
scanf("%d %d", &start, &end);
addEdge(&g, start, end);
}

printf("Enter the starting vertex for DFS: ");

scanf("%d", &startVertex);

bool visited[MAX] = {false};

printf("DFS starting from vertex %d: ", startVertex);
dfs(&g, startVertex, visited);

printf("\n");

return 0;
}

OUTPUT
Q25. Prim’s

#include <stdio.h>
#include <limits.h>

#define MAX 100

int adjMatrix[MAX][MAX];
int parent[MAX];
int key[MAX];
int mstSet[MAX];

void primMST(int numVertices) {

for (int i = 0; i < numVertices; i++) {
key[i] = INT_MAX;
mstSet[i] = 0;
}

key[0] = 0;
parent[0] = -1;

for (int count = 0; count < numVertices - 1; count++) {

int u = -1;
for (int v = 0; v < numVertices; v++) {
if (!mstSet[v] && (u == -1 || key[v] < key[u])) {
u = v;
}
}

mstSet[u] = 1;

for (int v = 0; v < numVertices; v++) {

 if (adjMatrix[u][v] && !mstSet[v] && adjMatrix[u][v] < key[v]) {
parent[v] = u;
key[v] = adjMatrix[u][v];
}
}
}

printf("Edge \tWeight\n");
for (int i = 1; i < numVertices; i++) {
printf("%d - %d \t%d\n", parent[i], i, adjMatrix[i][parent[i]]);
}
}

int main() {
int numVertices, numEdges, start, end, weight;

printf("Enter number of vertices: ");

scanf("%d", &numVertices);

for (int i = 0; i < numVertices; i++) {

for (int j = 0; j < numVertices; j++) {
adjMatrix[i][j] = 0;
}
}

printf("Enter number of edges: ");

scanf("%d", &numEdges);

printf("Enter the edges (start, end, weight):\n");

for (int i = 0; i < numEdges; i++) {
scanf("%d %d %d", &start, &end, &weight);
adjMatrix[start][end] = weight;
adjMatrix[end][start] = weight;
}

primMST(numVertices);

return 0;
}

OUTPUT
Q26. Kruskal's

#include <stdio.h>
#include <stdlib.h>

#define MAX 100

struct Edge {
int start, end, weight;
};

struct Graph {
int numVertices, numEdges;
struct Edge edges[MAX];
};

int parent[MAX];

int find(int i) {
if (parent[i] == i)
return i;
return find(parent[i]);
}

void unionSets(int x, int y) {

parent[x] = y;
}
int compare(const void* a, const void* b) {
return ((struct Edge*)a)->weight - ((struct Edge*)b)->weight;
}

void kruskal(struct Graph* g) {

qsort(g->edges, g->numEdges, sizeof(struct Edge), compare);

for (int i = 0; i < g->numVertices; i++)

parent[i] = i;

int mstWeight = 0;
printf("Edge \tWeight\n");

for (int i = 0; i < g->numEdges; i++) {

int u = find(g->edges[i].start);
int v = find(g->edges[i].end);

if (u != v) {
unionSets(u, v);
printf("%d - %d \t%d\n", g->edges[i].start, g->edges[i].end, g->edges[i].weight);
mstWeight += g->edges[i].weight;
}
}

printf("Total weight of MST: %d\n", mstWeight);

}

int main() {
struct Graph g;

printf("Enter number of vertices: ");

scanf("%d", &g.numVertices);

printf("Enter number of edges: ");

scanf("%d", &g.numEdges);

printf("Enter the edges (start, end, weight):\n");

for (int i = 0; i < g.numEdges; i++) {
scanf("%d %d %d", &g.edges[i].start, &g.edges[i].end, &g.edges[i].weight);
}

kruskal(&g);
 return 0;
}

OUTPUT

Q27. Dijkstra’s Algorithm.

#include <stdio.h>
#include <limits.h>

#define MAX 10

int graph[MAX][MAX];
int dist[MAX];
int visited[MAX];

void dijkstra(int n, int start) {

for (int i = 0; i < n; i++) {
dist[i] = INT_MAX;
visited[i] = 0;
}

dist[start] = 0;

for (int count = 0; count < n-1; count++) {

int u = -1;
for (int i = 0; i < n; i++) {
if (!visited[i] && (u == -1 || dist[i] < dist[u])) {
 u = i;
}
}

visited[u] = 1;

for (int v = 0; v < n; v++) {

if (graph[u][v] != 0 && !visited[v] && dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
}
}
}

printf("Vertex Distance from Source\n");

for (int i = 0; i < n; i++) {
printf("%d \t\t%d\n", i, dist[i]);
}
}

int main() {
int n, edges, u, v, w, start;

printf("Enter the number of vertices: ");

scanf("%d", &n);

printf("Enter the number of edges: ");

scanf("%d", &edges);

for (int i = 0; i < edges; i++) {

printf("Enter edge (start vertex, end vertex, weight): ");
scanf("%d %d %d", &u, &v, &w);
graph[u][v] = w;
graph[v][u] = w;
}

printf("Enter the source vertex: ");

scanf("%d", &start);

dijkstra(n, start);

return 0;
}
OUTPUT