EXERCISE - 1

Experiment 1:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
char a = 160;
// It will overflow the required 1 byte size
// 160 - 127 = 33
// -128 + 33 = -95-1 = -96 ( gap of -128 and 127)
printf("a = %d", a);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\DSA\" ; if
($?) { gcc 1_1.c -o 1_1 } ; if ($?) { .\1_1 }
a = -96

Experiment 2:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
int a = 600;
char *p = (char *)&a;
// Char pointer will use 1 byte having the binary
// 01011000 which is 88 for the binary of 600 which is
1001011000
 printf("%d", *p);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 1_2.c -o 1_2 } ; if ($?) { .\1_2 }
88

Experiment 3:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
int a = 330;
float *p = (float *)&a;
printf("%f", *p);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 1_3.c -o 1_3 } ; if ($?) { .\1_3 }
0.000000

Experiment 4:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
 int a = 100000;
// a*a = 10000000000 = 100000*100000
// 2^32 = 4294967296
// 2^31 = (2^32)/2 = 2147483648 (MSB)
// 2^31 - 1 = 2147483647 ( +ve integers)
// 10000000000 - 2147483647 = 7852516353
// 7852516353 - 2147483648 = 5705032705
// 5705032705 - 2147483647 = 3557549058
// 3557549058 - 2147483648 = 1410065410
// 1410065410 / 100000 = 14100.6541
// the result will be 14100.
printf("%d", (a * a) / a);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 1_4.c -o 1_4 } ; if ($?) { .\1_4 }
14100

Experiment 5:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
int a = 330;
int *p = &a;
// interger pointer takes full 4 bytes it will print the
exact value without failure
printf("%d", *p);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 1_5.c -o 1_5 } ; if ($?) { .\1_5 }
330

Experiment 6:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
int a = 2937;
// Void pointer has no access to address
void *p = &a;
// Explicit conversion
printf("%d", *((int *)p));
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 1_6.c -o 1_6 } ; if ($?) { .\1_6 }
2937

Experiment 7:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
void displayMatrix(float matrix[10][10], int n)
{
for (int i = 0; i < n; i++)
{
 for (int j = 0; j < n; j++)
{
printf("%8.3f", matrix[i][j]);
}
printf("\n");
}
}
int inverseMatrix(float matrix[10][10], float inverse[10][10],
int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
inverse[i][j] = (i == j) ? 1 : 0;
}
}
for (int i = 0; i < n; i++)
{
float diagElement = matrix[i][i];
if (diagElement == 0)
{
return 0;
}
for (int j = 0; j < n; j++)
{
matrix[i][j] /= diagElement;
inverse[i][j] /= diagElement;
}
for (int k = 0; k < n; k++)
{
if (k != i)
{
float factor = matrix[k][i];
for (int j = 0; j < n; j++)
{
matrix[k][j] -= factor * matrix[i][j];
inverse[k][j] -= factor * inverse[i][j];
}
}
}
}
return 1;
}
int main()
{
 float matrix[10][10], inverse[10][10];
int n;
printf("Enter the size of the matrix: ");
scanf("%d", &n);
if (n > 10 || n <= 0)
{
printf("Invalid matrix size.\n");
return -1;
}
printf("Enter elements of matrix: ");
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
scanf("%f", &matrix[i][j]);
}
}
if (inverseMatrix(matrix, inverse, n))
{
printf("Inverse Matrix:-\n");
displayMatrix(inverse, n);
}
else
{
printf("\nMatrix is singular and cannot be inverted.\
n");
}
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 1_7.c -o 1_7 } ; if ($?) { .\1_7 }
Enter the size of the matrix: 2
Enter elements of matrix: 1 2 3 4
Inverse Matrix:-
-2.000 1.000
1.500 -0.500

EXERCISE - 2
Experiment 1:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
float determinant(float matrix[10][10], int n)
{
float det = 0;
float submatrix[10][10];
int sign = 1;
if (n == 1)
{
return matrix[0][0];
}
if (n == 2)
{
return (matrix[0][0] * matrix[1][1]) - (matrix[0][1] *
matrix[1][0]);
}
for (int x = 0; x < n; x++)
{
int subi = 0;
for (int i = 1; i < n; i++)
{
int subj = 0;
for (int j = 0; j < n; j++)
{
if (j == x)
continue;
submatrix[subi][subj] = matrix[i][j];
subj++;
}
subi++;
}
det += sign * matrix[0][x] * determinant(submatrix, n -
1);
sign = -sign;
}
 return det;
}
void transposeMatrix(float matrix[10][10], float transpose[10]
[10], int rows, int columns)
{
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
transpose[j][i] = matrix[i][j];
}
}
}
int upperTriangular(int matrix[10][10], int n)
{
for (int i = 1; i < n; i++)
{
for (int j = 0; j < i; j++)
{
if (matrix[i][j] != 0)
{
return 0;
}
}
}
return 1;
}
int lowerTriangular(int matrix[10][10], int n)
{
for (int i = 0; i < n - 1; i++)
{
for (int j = i + 1; j < n; j++)
{
if (matrix[i][j] != 0)
{
return 0;
}
}
}
return 1;
}
int inverseMatrix(float matrix[10][10], float inverse[10][10],
int n)
{
float temp[10][10];
for (int i = 0; i < n; i++)
 {
for (int j = 0; j < n; j++)
{
temp[i][j] = matrix[i][j];
inverse[i][j] = (i == j) ? 1 : 0;
}
}

for (int i = 0; i < n; i++)

{
float diagElement = temp[i][i];
if (diagElement == 0)
{
return 0;
}
for (int j = 0; j < n; j++)
{
temp[i][j] /= diagElement;
inverse[i][j] /= diagElement;
}
for (int k = 0; k < n; k++)
{
if (k != i)
{
float factor = temp[k][i];
for (int j = 0; j < n; j++)
{
temp[k][j] -= factor * temp[i][j];
inverse[k][j] -= factor * inverse[i][j];
}
}
}
}
return 1;
}
int identityMatrix(int matrix[10][10], int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if ((i == j && matrix[i][j] != 1) || (i != j &&
matrix[i][j] != 0))
{
return 0;
}
 }
}
return 1;
}
int nullMatrix(int matrix[10][10], int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (matrix[i][j] != 0)
{
return 0;
}
}
}
return 1;
}
void displayMatrix(float matrix[10][10], int rows, int columns)
{
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
printf("%8.3f", matrix[i][j]);
}
printf("\n");
}
}
int main()
{
int rows, columns;
float matrix[10][10], transpose[10][10], inverse[10][10];
printf("Enter the rows of the matrix: ");
scanf("%d", &rows);
printf("Enter the columns of the matrix: ");
scanf("%d", &columns);
if (rows > 10 || columns > 10)
{
printf("Error: Matrix size exceeds 10x10\n");
return 1;
}
printf("Enter elements of matrix: ");
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
 {
scanf("%f", &matrix[i][j]);
}
}
printf("\nMatrix:-\n");
displayMatrix(matrix, rows, columns);
printf("\n");
int choice;
printf("1. Check matrix is square matrix or not\n");
printf("2. Calculate determinant\n");
printf("3. Transpose matrix\n");
printf("4. Check if symmetric or skew symmetric\n");
printf("5. Check if upper triangular\n");
printf("6. Check if lower triangular\n");
printf("7. Calculate inverse\n");
printf("8. Check matrix is identity matrix\n");
printf("9. Check matrix is null matrix\n");
printf("10. Exit\n");
while (1 && choice != 10)
{
printf("Enter your choice: ");
scanf("%d", &choice);
printf("\n");
switch (choice)
{
case 1:
if (rows == columns)
{
printf("--> The matrix is a square matrix\n");
}
else
{
printf("--> The matrix is not a square matrix\
n");
}
break;
case 2:
if (rows == columns)
{
printf("--> The determinant of the matrix is:
%.2f\n", determinant(matrix, rows));
}
else
{
printf("--> Determinant is only defined for
square matrices\n");
 }
break;
case 3:
transposeMatrix(matrix, transpose, rows, columns);
printf("--> Transpose of the matrix:-\n");
displayMatrix(transpose, columns, rows);
break;
case 4:
if (rows == columns)
{
transposeMatrix(matrix, transpose, rows,
columns);
int symmetric = 1, skewSymmetric = 1;

for (int i = 0; i < rows; i++)

{
for (int j = 0; j < columns; j++)
{
if (matrix[i][j] != transpose[i][j])
symmetric = 0;
if (matrix[i][j] != -transpose[i][j])
skewSymmetric = 0;
}
}
if (symmetric)
{
printf("--> The matrix is symmetric\n");
}
else if (skewSymmetric)
{
printf("--> The matrix is skew-symmetric\
n");
}
else
{
printf("--> The matrix is neither symmetric
nor skew-symmetric\n");
}
}
else
{
printf("--> Symmetry is only defined for square
matrices\n");
}
break;
case 5:
 if (upperTriangular((int(*)[10])matrix, rows))
{
printf("--> The matrix is upper triangular\n");
}
else
{
printf("--> The matrix is not upper triangular\
n");
}
break;
case 6:
if (lowerTriangular((int(*)[10])matrix, rows))
{
printf("--> The matrix is lower triangular.\n");
}
else
{
printf("--> The matrix is not lower triangular.\
n");
}
break;
case 7:
if (rows == columns)
{
if (inverseMatrix(matrix, inverse, rows))
{
printf("--> Inverse of the matrix:-\n");
displayMatrix(inverse, rows, columns);
}
else
{
printf("--> The matrix is not invertible\
n");
}
}
else
{
printf("--> Inverse is only defined for square
matrices\n");
}
break;
case 8:
if (identityMatrix((int(*)[10])matrix, rows))
{
printf("--> The matrix is an identity matrix\
n");
 }
else
{
printf("--> The matrix is not an identity
matrix\n");
}
break;
case 9:
if (nullMatrix((int(*)[10])matrix, rows))
{
printf("--> The matrix is a null matrix\n");
}
else
{
printf("--> The matrix is not a null matrix\n");
}
break;
case 10:
printf("--> Exiting the program\n");
break;
default:
printf("--> Error! Invalid choice\n");
break;
}
printf("\n");
}
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 2_1.c -o 2_1 } ; if ($?) { .\2_1 }
Enter the rows of the matrix: 2
Enter the columns of the matrix: 2
Enter elements of matrix: 1 2 3 4

Matrix:-
1.000 2.000
3.000 4.000

1. Check matrix is square matrix or not

2. Calculate determinant
3. Transpose matrix
4. Check if symmetric or skew symmetric
5. Check if upper triangular
6. Check if lower triangular
7. Calculate inverse
8. Check matrix is identity matrix
9. Check matrix is null matrix
10. Exit
Enter your choice: 1

--> The matrix is a square matrix

Enter your choice: 2

--> The determinant of the matrix is: -2.00

Enter your choice: 3

--> Transpose of the matrix:-

1.000 3.000
2.000 4.000

Enter your choice: 4

--> The matrix is neither symmetric nor skew-symmetric

Enter your choice: 5

--> The matrix is not upper triangular

Enter your choice: 6

--> The matrix is not lower triangular.

Enter your choice: 7

--> Inverse of the matrix:-

-2.000 1.000
1.500 -0.500

Enter your choice: 8

--> The matrix is not an identity matrix

Enter your choice: 9

--> The matrix is not a null matrix

Enter your choice: 10

--> Exiting the program

Experiment 2:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
int a, b, c;
printf("Enter the size of 3d array: ");
scanf("%d %d %d", &a, &b, &c);
 int arr[a][b][c];
printf("enter element: ");
for (int i = 0; i < a; i++)
{
for (int j = 0; j < b; j++)
{
for (int k = 0; k < c; k++)
{
scanf("%d", &arr[i][j][k]);
}
}
}
printf("%u\n", arr);
printf("%u\n", arr + 1);
printf("%u\n", &arr );
printf("%u\n", &arr + 1);
printf("%u\n", *arr);
printf("%u\n", *arr + 1);
printf("%u\n", **arr);
printf("%u\n", **arr + 1);
printf("%u\n", ***arr);
printf("%u\n", ***arr + 1);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 2_2.c -o 2_2 } ; if ($?) { .\2_2 }
Enter the size of 3d array: 3 2 2
enter element: 1 2 3 4 5 6 7 8 9 10 11 12
6422128
6422144
6422128
6422176
6422128
6422136
6422128
6422132
1
2
Experiment 3:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
int a, b;
printf("Enter the size of 2d array: ");
scanf("%d %d", &a, &b);
int arr[a][b];
printf("enter element: ");
for (int i = 0; i < a; i++)
{
for (int j = 0; j < b; j++)
{
scanf("%d", &arr[i][j]);
}
}
printf("%u\n", arr);
printf("%u\n", arr + 1);
printf("%u\n", &arr);
printf("%u\n", &arr + 1);
printf("%u\n", *arr);
printf("%u\n", *arr + 1);
printf("%u\n", **arr);
printf("%u\n", **arr + 1);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 2_3.c -o 2_3 } ; if ($?) { .\2_3 }
Enter the size of 2d array: 4 3
enter element: 1 2 3 4 5 6 7 8 9 10 11 12
6422156
6422168
6422156
6422204
6422156
6422160
1
2

EXERCISE - 3
Experiment 1:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
int a[4] = {10, 20, 30, 40};
int *p[4] = {a + 3, a + 2, a + 1, a};
int j;
j = --p[0] - p[1];
printf("%d\n", j);
printf("%d\n", *p[0]);
return 0;
}

Output :-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 3_1.c -o 3_1 } ; if ($?) { .\3_1 }
0
30

Experiment 2:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
int main()
{
float a = 1.2;
if (a == 1.2)
{
printf("IIIT\n");
}
else
{
printf("MANIT\n");
}
return 0;
}

Output :-
PS C:\Users\devu\2nd semester\DSA> cd "c:\Users\devu\2nd
semester\DSA\" ; if ($?) { gcc 3_2.c -o 3_2 } ; if ($?) { .\
3_2 }
MANIT

Experiment 3:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <stdlib.h>
struct Node
{
int data;
struct Node *next;
};
struct Node *insert(struct Node *head, int data)
{
 struct Node *newNode = (struct Node *)malloc(sizeof(struct
Node));
newNode->data = data;
newNode->next = NULL;
if (head == NULL)
{
return newNode;
}
struct Node *temp = head;
while (temp->next != NULL)
{
temp = temp->next;
}
temp->next = newNode;
return head;
}
void list(struct Node *head)
{
struct Node *temp = head;
while (temp != NULL)
{
printf("%d --> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}
void reverseHelper(struct Node *head)
{
if (head == NULL)
{
return;
}
reverseHelper(head->next);
printf("%d <-- ", head->data);
}
void reverse(struct Node *head)
{
if (head == NULL)
{
printf("NULL\n");
return;
}
reverseHelper(head);
printf("NULL\n");
}
int main()
{
struct Node *head = NULL;
for (int i = 1; i <= 5; i++)
{
head = insert(head, i);
}
printf("Linked List in forward order:\n");
list(head);
printf("Linked List in reverse order:\n");
reverse(head);
return 0;
}

Output :-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\" ; if ($?) { gcc 3_3.c -o 3_3 } ; if ($?) { .\3_3 }
Linked List in forward order:
1 --> 2 --> 3 --> 4 --> 5 --> NULL
Linked List in reverse order:
5 <-- 4 <-- 3 <-- 2 <-- 1 <-- NULL

EXERCISE – 4
Experiment 1 (a^n with for loop):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
void power(int a, int n, long long *result)
{
*result = 1;
for (int i = 1; i <= n; i++)
{
*result *= a;
}
}
int main()
{
int a, n;
 long long result;
clock_t start, end;
double cpu_time_used;
printf("Enter a: ");
scanf("%d", &a);
printf("Enter n: ");
scanf("%d", &n);
start = clock();
power(a, n, &result);
end = clock();
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("%d^%d = %lld\n", a, n, result);
printf("Time taken: %f seconds\n", cpu_time_used);
return 0;
}

Output :-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\4\" ; if ($?) { gcc 1.c -o 1 } ; if ($?) { .\1 }
Enter a: 10
Enter n: 10
10^10 = 10000000000
Time taken: 0.000002 seconds

Experiment 2 (a^n with divide and

conquer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
long long power(int a, int n)
{
if (n == 0)
{
return 1;
}
long long half_power = power(a, n / 2);
if (n % 2 == 0)
 {
return half_power * half_power;
}
else
{
return a * half_power * half_power;
}
}
int main()
{
int a, n;
long long result;
clock_t start, end;
double cpu_time_used;
printf("Enter a: ");
scanf("%d", &a);
printf("Enter n: ");
scanf("%d", &n);
start = clock();
result = power(a, n);
end = clock();
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("%d^%d = %lld\n", a, n, result);
printf("Time taken: %f seconds\n", cpu_time_used);
return 0;
}

Output :-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\4\" ; if ($?) { gcc 2.c -o 2 } ; if ($?) { .\2 } Enter a: 10
Enter n: 10
10^10 = 10000000000
Time taken: 0.000001 seconds
Experiment 3 (a^n with optimizer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
long long power(int a, int n)
{
long long result = 1;
long long base = a;
while (n > 0)
{
if (n % 2 == 1)
{
result *= base;
}
base *= base;
n /= 2;
}
return result;
}
int main()
{
int a, n;
long long result;
clock_t start, end;
double cpu_time_used;
printf("Enter a: ");
scanf("%d", &a);
printf("Enter n: ");
scanf("%d", &n);
start = clock();
result = power(a, n);
end = clock();
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("%d^%d = %lld\n", a, n, result);
printf("Time taken: %f seconds\n", cpu_time_used);
return 0;
}
Output :-
PS C:\Users\devu\practice> cd "c:\Users\devu\practice\" ; if
($?) { gcc 53.c -o 53 } ; if ($?) { .\53 }
Enter a: 10
Enter n: 10
10^10 = 10000000000
Time taken: 0.000002 seconds

Experiment 4 (max and min with for

loop):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <limits.h>
#include <time.h>
void findMaxMin(int arr[], int size, int *max, int *min)
{
*max = INT_MIN;
*min = INT_MAX;
for (int i = 0; i < size; i++)
{
if (arr[i] > *max)
{
*max = arr[i];
}
if (arr[i] < *min)
{
*min = arr[i];
}
}
}
int main()
{
int n;
printf("enter size of array: ");
scanf("%d", &n);
int arr[n];
printf("enter element of array: ");
for (int i = 0; i < n; i++)
{
 scanf("%d", &arr[i]);
}
int size = sizeof(arr) / sizeof(arr[0]);
int max, min;
clock_t start = clock();
findMaxMin(arr, size, &max, &min);
clock_t end = clock();
double time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Maximum value: %d\n", max);
printf("Minimum value: %d\n", min);
printf("Time taken to find max and min: %f seconds\n",
time_taken);
return 0;
}

Output :-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\4\" ; if ($?) { gcc 4.c -o 4 } ; if ($?) { .\4 }
enter size of array: 5
enter element of array: 11 435 6965 13312 411
Maximum value: 13312
Minimum value: 11
Time taken to find max and min: 0.000002 seconds

Experiment 5 (max and min with

divide and conquer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <limits.h>
#include <time.h>
void findMaxMinDivideConquer(int arr[], int low, int high, int *max,
int *min)
{
if (low == high)
{
*max = arr[low];
*min = arr[low];
return;
}
if (high == low + 1)
{
if (arr[low] > arr[high])
{
*max = arr[low];
*min = arr[high];
}
else
{
*max = arr[high];
*min = arr[low];
}
return;
}
int mid = (low + high) / 2;
int max1, min1, max2, min2;
findMaxMinDivideConquer(arr, low, mid, &max1, &min1);
findMaxMinDivideConquer(arr, mid + 1, high, &max2, &min2);
*max = (max1 > max2) ? max1 : max2;
*min = (min1 < min2) ? min1 : min2;
}
int main()
{
int n;
printf("Enter size of array: ");
scanf("%d", &n);
int arr[n];
printf("Enter elements of array: ");
for (int i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
int max, min;
clock_t start = clock();
findMaxMinDivideConquer(arr, 0, n - 1, &max, &min);
clock_t end = clock();
double time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Maximum value: %d\n", max);
printf("Minimum value: %d\n", min);
 printf("Time taken to find max and min: %f seconds\n",
time_taken);
return 0;
}

Output :-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\4\" ; if ($?) { gcc 5.c -o 5 } ; if ($?) { .\5 }
Enter size of array: 5
Enter elements of array: 11 435 6965 13312 411
Maximum value: 13312
Minimum value: 11
Time taken to find max and min: 0.000001 seconds

Experiment 6 (max and min with

optimizer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <limits.h>
#include <time.h>
void findMaxMin(int arr[], int size, int *max, int *min)
{
*max = INT_MIN;
*min = INT_MAX;
for (int i = 0; i < size; i += 2)
{
if (i + 1 < size)
{
if (arr[i] > arr[i + 1])
{
if (arr[i] > *max)
*max = arr[i];
if (arr[i + 1] < *min)
*min = arr[i + 1];
}
else
{
if (arr[i + 1] > *max)
*max = arr[i + 1];
if (arr[i] < *min)
*min = arr[i];
 }
}
else
{
if (arr[i] > *max)
*max = arr[i];
if (arr[i] < *min)
*min = arr[i];
}
}
}
int main()
{
int n;
printf("Enter size of array: ");
scanf("%d", &n);
int arr[n];
printf("Enter elements of array: ");
for (int i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
int max, min;
clock_t start = clock();
findMaxMin(arr, n, &max, &min);
clock_t end = clock();
double time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Maximum value: %d\n", max);
printf("Minimum value: %d\n", min);
printf("Time taken to find max and min: %f seconds\n",
time_taken);
return 0;
}

Output :-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\4\" ; if ($?) { gcc 6.c -o 6 } ; if ($?) { .\6 }
Enter size of array: 5
Enter elements of array: 11 435 6965 13312 411
Maximum value: 13312
Minimum value: 11
Time taken to find max and min: 0.000002 seconds
 EXERCISE – 5

Experiment 1 (merge sort with for

loop):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
void merge(int arr[], int left, int mid, int right)
{
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; i++)
{
L[i] = arr[left + i];
}
for (int j = 0; j < n2; j++)
{
R[j] = arr[mid + 1 + j];
}
int i = 0, j = 0, k = left;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
 }
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int left, int right)
{
if (left < right)
{
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
int main()
{
int size;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
double cpu_time_used;
start = clock();
 mergeSort(arr, 0, size - 1);
end = clock();
printf("Sorted array: ");
printArray(arr, size);
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Time taken by Merge Sort: %f seconds\n",
cpu_time_used);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 1.c -o 1 } ; if ($?) { .\1 }
enter size of array: 5
enter elements of array: 457 132 6478 3241 76
Sorted array: 76 132 457 3241 6478
Time taken by Merge Sort: 0.000003 seconds

Experiment 2 (merge sort with divide

and conquer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
void merge(int arr[], int left, int mid, int right)
{
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; i++)
{
L[i] = arr[left + i];
 }
for (int j = 0; j < n2; j++)
{
R[j] = arr[mid + 1 + j];
}
int i = 0, j = 0, k = left;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int n)
{
int curr_size;
int left_start;
for (curr_size = 1; curr_size < n; curr_size *= 2)
{
for (left_start = 0; left_start < n - 1; left_start += 2
* curr_size)
{
int mid = left_start + curr_size - 1;
int right_end = (left_start + 2 * curr_size - 1 < n
- 1) ? (left_start + 2 * curr_size - 1) : (n - 1);
merge(arr, left_start, mid, right_end);
 }
}
}
void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int size;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
double cpu_time_used;
start = clock();
mergeSort (arr, size);
end = clock();
printf("Sorted array: ");
printArray(arr, size);
cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Time taken by Merge Sort: %f seconds\n",
cpu_time_used);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 2.c -o 2 } ; if ($?) { .\2 }
enter size of array: 5
enter elements of array: 457 132 6478 3241 76
Sorted array: 76 132 457 3241 6478
Time taken by Merge Sort: 0.000003 seconds
Experiment 3 (quick sort with for
loop):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
#define MAX_STACK 1000
int partition(int arr[], int low, int high) {
int pivot = arr[high], i = low - 1, temp;
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}
void quickSort(int arr[], int low, int high) {
int stack[MAX_STACK], top = -1, pivotIndex;
stack[++top] = low;
stack[++top] = high;
while (top >= 0) {
high = stack[top--];
low = stack[top--];
pivotIndex = partition(arr, low, high);
if (pivotIndex - 1 > low) {
stack[++top] = low;
stack[++top] = pivotIndex - 1;
}
if (pivotIndex + 1 < high) {
stack[++top] = pivotIndex + 1;
stack[++top] = high;
}
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int size;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
start = clock();
quickSort(arr, 0, size - 1);
end = clock();
printf("Sorted array: ");
printArray(arr, size);
double time_taken = ((double)(end - start)) /
CLOCKS_PER_SEC;
printf("Time taken: %f seconds\n", time_taken);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 3.c -o 3 } ; if ($?) { .\3 }
enter size of array: 5
enter elements of array: 457 132 6478 3241 76
Sorted array: 76 132 457 3241 6478
Time taken: 0.000002 seconds

Experiment 4 (quick sort with divide

and conquer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.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 size;
 printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
start = clock();
quickSort(arr, 0, size - 1);
end = clock();
printf("Sorted array: ");
printArray(arr, size);
double time_taken = ((double)(end - start)) /
CLOCKS_PER_SEC;
printf("Time taken: %f seconds\n", time_taken);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 4.c -o 4 } ; if ($?) { .\4 }
enter size of array: 5
enter elements of array: 457 132 6478 3241 76
Sorted array: 76 132 457 3241 6478
Time taken by Merge Sort: 0.000002 seconds

Experiment 5 (bubble sort with for

loop):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
void bubbleSort(int arr[], int n)
{
int i, j, temp;
 for (i = 0; i < n - 1; i++)
{
for (j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int size;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
double time_taken;
start = clock();
bubbleSort(arr, size);
end = clock();
time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Sorted array: ");
printArray(arr, size);
printf("Time taken: %f seconds\n", time_taken);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 5.c -o 5 } ; if ($?) { .\5 }
enter size of array: 5
enter elements of array: 457 132 6478 3241 76
Sorted array: 76 132 457 3241 6478
Time taken: 0.000002 seconds

Experiment 6 (bubble sort with divide

and conquer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
void bubbleSort(int arr[], int n)
{
if (n == 1)
{
return;
}
for (int i = 0; i < n - 1; i++)
if (arr[i] > arr[i + 1])
{
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
bubbleSort(arr, n - 1);
}
void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
 int size;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
double time_taken;
start = clock();
bubbleSort(arr, size);
end = clock();
time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Sorted array: ");
printArray(arr, size);
printf("Time taken: %f seconds\n", time_taken);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 6.c -o 6 } ; if ($?) { .\6 }
enter size of array: 5
enter elements of array: 457 132 6478 3241 76
Sorted array: 76 132 457 3241 6478
Time taken by Merge Sort: 0.000002 seconds

Experiment 7 (binary search with for

loop):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
int binarySearch(int arr[], int n, int key)
{
int left = 0, right = n - 1;
for (; left <= right;)
{
int mid = left + (right - left) / 2;
if (arr[mid] == key)
{
return mid;
}
else if (arr[mid] < key)
{
left = mid + 1;
}
else
{
right = mid - 1;
}
}
return -1;
}
int main()
{
int size, key;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of sorted array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
printf("Enter the key to search: ");
scanf("%d", &key);
clock_t start = clock();
int result = binarySearch(arr, size, key);
clock_t end = clock();
if (result != -1)
{
printf("Element found at index %d\n", result);
}
else
{
printf("Element not found\n");
}
double time_taken = ((double)(end - start)) /
CLOCKS_PER_SEC;
 printf("Time taken: %f seconds\n", time_taken);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 7.c -o 7 } ; if ($?) { .\7 }
enter size of array: 5
enter elements of sorted array: 243 5321 34254 234543 2355644
Enter the key to search: 5321
Element found at index 1
Time taken: 0.000002 seconds

Experiment 8 (binary search with

divide and conquer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
int binarySearch(int arr[], int left, int right, int key)
{
if (left > right)
{
return -1;
}
int mid = left + (right - left) / 2;
if (arr[mid] == key)
{
return mid;
}
else if (arr[mid] < key)
{
return binarySearch(arr, mid + 1, right, key);
}
else
{
 return binarySearch(arr, left, mid - 1, key);
}
}
int main()
{
int size, key;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of sorted array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
printf("Enter the key to search: ");
scanf("%d", &key);
clock_t start = clock();
int result = binarySearch(arr, 0, size - 1, key);
clock_t end = clock();
if (result != -1)
{
printf("Element found at index %d\n", result);
}
else
{
printf("Element not found\n");
}
double time_taken = ((double)(end - start)) /
CLOCKS_PER_SEC;
printf("Time taken: %f seconds\n", time_taken);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 8.c -o 8 } ; if ($?) { .\8 }
enter size of array: 5
enter elements of sorted array: 243 5321 34254 234543 2355644
Enter the key to search: 5321
Element found at index 1
Time taken: 0.000001 seconds
Experiment 9 (quick select with for
loop):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int partition(int arr[], int low, int high)
{
int pivot = arr[high];
int i = low - 1;
for (int j = low; j <= high - 1; j++)
{
if (arr[j] <= pivot)
{
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}
int quickSelect(int arr[], int low, int high, int k)
{
if (low <= high)
{
int pivotIndex = partition(arr, low, high);
if (pivotIndex == k)
{
return arr[pivotIndex];
}
else if (pivotIndex > k)
{
return quickSelect(arr, low, pivotIndex - 1, k);
}
else
{
 return quickSelect(arr, pivotIndex + 1, high, k);
}
}
return -1;
}
int main()
{
int size, key;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of sorted array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
printf("Enter the value of key (1-based index): ");
scanf("%d", &key);
if (key < 1 || key > size)
{
printf("Invalid k value!\n");
return 1;
}
clock_t start = clock();
int result = quickSelect(arr, 0, size - 1, key - 1);
clock_t end = clock();
printf("The %d-th smallest element is: %d\n", key, result);
printf("Time taken: %lf seconds\n", (double)(end - start) /
CLOCKS_PER_SEC);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 9.c -o 9 } ; if ($?) { .\9 }
enter size of array: 5
enter elements of sorted array: 243 5321 34254 234543 23556441
Enter the value of key (1-based index): 1
The 1-th smallest element is: 243
Time taken: 0.000002 seconds
Experiment 10 (quick select with
divide and conquer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int partition(int arr[], int left, int right)
{
int pivot = arr[right];
int i = left;
for (int j = left; j < right; j++)
{
if (arr[j] <= pivot)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
}
}
int temp = arr[i];
arr[i] = arr[right];
arr[right] = temp;
return i;
}
int quickSelect(int arr[], int left, int right, int k)
{
if (left <= right)
{
int pivotIndex = partition(arr, left, right);
if (pivotIndex == k)
{
return arr[pivotIndex];
}
else if (pivotIndex > k)
{
return quickSelect(arr, left, pivotIndex - 1, k);
 }
else
{
return quickSelect(arr, pivotIndex + 1, right, k);
}
}
return -1;
}
int main()
{
int size, key;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of sorted array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
printf("Enter the value of key (1-based index): ");
scanf("%d", &key);
if (key < 1 || key > size)
{
printf("Invalid k value!\n");
return 1;
}
clock_t start = clock();
int result = quickSelect(arr, 0, size - 1, key - 1);
clock_t end = clock();
printf("The %d-th smallest element is: %d\n", key, result);
printf("Time taken: %lf seconds\n", (double)(end - start) /
CLOCKS_PER_SEC);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\5\" ; if ($?) { gcc 10.c -o 10 } ; if ($?) { .\10 }
enter size of array: 5
enter elements of sorted array: 243 5321 34254 234543 23556441
Enter the value of key (1-based index): 1
The 1-th smallest element is: 243
Time taken: 0.000002 seconds

EXERCISE – 6
Experiment 1:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
void bubbleSort(int arr[], int n)
{
if (n == 1)
{
return;
}
for (int i = 0; i < n - 1; i++)
if (arr[i] > arr[i + 1])
{
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
bubbleSort(arr, n - 1);
}
void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int size;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
double time_taken;
start = clock();
bubbleSort(arr, size);
end = clock();
time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
 printf("Sorted array: ");
printArray(arr, size);
printf("Time taken: %f seconds\n", time_taken);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\6\" ; if ($?) { gcc 1.c -o 1 } ; if ($?) { .\1 }
enter size of array: 5
enter elements of array: 231 547 432 123 64
Sorted array: 64 123 231 432 547
Time taken: 0.000001 seconds

Experiment 2:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
void selectionSort(int arr[], int n)
{
for (int i = 0; i < n - 1; i++)
{
int min = i;
for (int j = i + 1; j < n; j++)
{
if (arr[j] < arr[min])
{
min = j;
}
}
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
 printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int size;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
double time_taken;
start = clock();
selectionSort(arr, size);
end = clock();
time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Sorted array: ");
printArray(arr, size);
printf("Time taken: %f seconds\n", time_taken);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\6\" ; if ($?) { gcc 2.c -o 2 } ; if ($?) { .\2 }
enter size of array: 5
enter elements of array: 231 547 432 123 64
Sorted array: 64 123 231 432 547
Time taken: 0.000002 seconds

Experiment 3:-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <time.h>
void radixSort(int arr[], int n)
{
int max = arr[0];
for (int i = 1; i < n; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
}
for (int exp = 1; max / exp > 0; exp *= 10)
{
int output[n];
int count[10] = {0};
for (int i = 0; i < n; i++)
{
count[(arr[i] / exp) % 10]++;
}
for (int i = 1; i < 10; i++)
{
count[i] += count[i - 1];
}
for (int i = n - 1; i >= 0; i--)
{
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
for (int i = 0; i < n; i++)
{
arr[i] = output[i];
}
}
}
void printArray(int arr[], int size)
{
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int size;
printf("enter size of array: ");
scanf("%d", &size);
int arr[size];
 printf("enter elements of array: ");
for (int i = 0; i < size; i++)
{
scanf("%d", &arr[i]);
}
clock_t start, end;
double time_taken;
start = clock();
radixSort(arr, size);
end = clock();
time_taken = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Sorted array: ");
printArray(arr, size);
printf("Time taken: %f seconds\n", time_taken);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\6\" ; if ($?) { gcc 3.c -o 3 } ; if ($?) { .\3 }
enter size of array: 5
enter elements of array: 231 547 432 123 64
Sorted array: 64 123 231 432 547
Time taken: 0.000002 seconds

EXERCISE – 7
Experiment 1(stack with linked list):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <stdlib.h>
struct Node
{
int data;
struct Node *next;
};
struct Stack
{
struct Node *top;
};
void initStack(struct Stack *stack)
{
 stack->top = NULL;
}
void push(struct Stack *stack, int value)
{
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
if (!newNode)
{
printf("Stack Overflow! Memory allocation failed.\n");
return;
}
newNode->data = value;
newNode->next = stack->top;
stack->top = newNode;
printf("%d pushed to stack.\n", value);
}
void pop(struct Stack *stack)
{
if (stack->top == NULL)
{
printf("Stack Underflow! Cannot pop from empty stack.\n");
return;
}
struct Node *temp = stack->top;
printf("Popped: %d\n", temp->data);
stack->top = temp->next;
free(temp);
}
int peek(struct Stack *stack)
{
if (stack->top == NULL)
{
printf("Stack is empty!\n");
return -1;
}
return stack->top->data;
}
int isEmpty(struct Stack *stack)
{
return stack->top == NULL;
}
void display(struct Stack *stack)
{
if (stack->top == NULL)
{
printf("Stack is empty!\n");
return;
}
struct Node *temp = stack->top;
printf("Stack elements: ");
while (temp)
 {
printf("%d -> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}
int main()
{
struct Stack stack;
initStack(&stack);
push(&stack, 10);
push(&stack, 20);
push(&stack, 30);
display(&stack);
printf("Top element: %d\n", peek(&stack));
pop(&stack);
display(&stack);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\DSA\
7\" ; if ($?) { gcc 1.c -o 1 } ; if ($?) { .\1 }
10 pushed to stack.
20 pushed to stack.
30 pushed to stack.
Stack elements: 30 -> 20 -> 10 -> NULL
Top element: 30
Popped: 30
Stack elements: 20 -> 10 -> NULL

Experiment 2(stack with array):-

/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
struct Stack
{
int top;
int arr[MAX];
};
void initStack(struct Stack *stack)
{
 stack->top = -1;
}
void push(struct Stack *stack, int value)
{
if (stack->top >= MAX - 1)
{
printf("Stack Overflow!\n");
return;
}
stack->arr[++stack->top] = value;
printf("Pushed: %d\n", value);
}
void pop(struct Stack *stack)
{
if (stack->top < 0)
{
printf("Stack Underflow!\n");
return;
}
printf("Popped: %d\n", stack->arr[stack->top--]);
}
int peek(struct Stack *stack)
{
if (stack->top < 0)
{
printf("Stack is Empty!\n");
return -1;
}
return stack->arr[stack->top];
}
int isEmpty(struct Stack *stack)
{
return stack->top == -1;
}
void display(struct Stack *stack)
{
if (stack->top < 0)
{
printf("Stack is Empty!\n");
return;
}
printf("Stack elements: ");
for (int i = 0; i <= stack->top; i++)
printf("%d ", stack->arr[i]);
printf("\n");
}
int main()
{
struct Stack s;
initStack(&s);
 push(&s, 10);
push(&s, 20);
push(&s, 30);
display(&s);
printf("Top element: %d\n", peek(&s));
pop(&s);
display(&s);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\
DSA\7\" ; if ($?) { gcc 2.c -o 2 } ; if ($?) { .\2 }
Pushed: 10
Pushed: 20
Pushed: 30
Stack elements: 10 20 30
Top element: 30
Popped: 30
Stack elements: 10 20

EXERCISE – 8
Experiment 1 (Infix to Postfix):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define MAX 100
typedef struct
{
char arr[MAX];
int top;
} Stack;
void push(Stack *s, char c)
{
if (s->top == MAX - 1)
{
printf("Stack Overflow\n");
return;
}
s->arr[++(s->top)] = c;
}
char pop(Stack *s)
{
if (s->top == -1)
{
printf("Stack Underflow\n");
return -1;
}
return s->arr[(s->top)--];
}
char peek(Stack *s)
{
return (s->top == -1) ? -1 : s->arr[s->top];
}
int precedence(char op)
{
switch (op)
{
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
case '^':
return 3;
default:
return 0;
}
}
int operator(char c)
{
return (c == '+' || c == '-' || c == '*' || c == '/' || c == '^');
}
void infixToPostfix(char *infix, char *postfix)
{
Stack s;
s.top = -1;
int i = 0, j = 0;
char c;
while (infix[i] != '\0')
{
c = infix[i];
if (isalnum(c))
{
postfix[j++] = c;
}
else if (c == '(')
{
push(&s, c);
}
 else if (c == ')')
{
while (s.top != -1 && peek(&s) != '(')
{
postfix[j++] = pop(&s);
}
pop(&s);
}
else if (operator(c))
{
while (s.top != -1 && precedence(peek(&s)) >=
precedence(c))
{
postfix[j++] = pop(&s);
}
push(&s, c);
}
i++;
}
while (s.top != -1)
{
postfix[j++] = pop(&s);
}
postfix[j] = '\0';
}
int main()
{
char infix[MAX], postfix[MAX];
printf("Enter infix expression: ");
scanf("%s", infix);
infixToPostfix(infix, postfix);
printf("Postfix expression: %s\n", postfix);
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\DSA\
8\" ; if ($?) { gcc 1.c -o 1 } ; if ($?) { .\1 }
Enter infix expression: 5*3(2+6)-2/5
Postfix expression: 5326+*25/-
Experiment 2 (postfix direct answer):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAX 100
typedef struct
{
int arr[MAX];
int top;
} Stack;
void push(Stack *s, int val)
{
if (s->top == MAX - 1)
return;
s->arr[++(s->top)] = val;
}
int pop(Stack *s)
{
return (s->top == -1) ? -1 : s->arr[(s->top)--];
}
int evaluatePostfix(char *postfix)
{
Stack s;
s.top = -1;
int i, op1, op2;
for (i = 0; postfix[i] != '\0'; i++)
{
if (isdigit(postfix[i]))
{
push(&s, postfix[i] - '0');
}
else
{
op2 = pop(&s);
op1 = pop(&s);
switch (postfix[i])
{
case '+':
push(&s, op1 + op2);
break;
case '-':
push(&s, op1 - op2);
break;
 case '*':
push(&s, op1 * op2);
break;
case '/':
push(&s, op1 / op2);
break;
}
}
}
return pop(&s);
}
int main()
{
char postfix[MAX];
printf("Enter a postfix expression: ");
scanf("%s", postfix);
printf("Result: %d\n", evaluatePostfix(postfix));
return 0;
}

Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\DSA\
8\" ; if ($?) { gcc 2.c -o 2 } ; if ($?) { .\2 }
Enter a postfix expression: 5*3(2+6)-2/5
Result: 5

EXERCISE – 9
Experiment 1 (doubly linked list):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#include <stdlib.h>
struct Node
{
int data;
struct Node *prev;
struct Node *next;
};
struct Node *createNode(int data)
{
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
newNode->data = data;
newNode->prev = NULL;
newNode->next = NULL;
return newNode;
}
void insertEnd(struct Node **head, int data)
{
struct Node *newNode = createNode(data);
if (*head == NULL)
{
*head = newNode;
return;
}
struct Node *temp = *head;
while (temp->next != NULL)
temp = temp->next;
temp->next = newNode;
newNode->prev = temp;
}
void displayForward(struct Node *head)
{
printf("List (Forward): ");
while (head != NULL)
{
printf("%d ", head->data);
head = head->next;
}
printf("\n");
}
void displayBackward(struct Node *head)
{
if (head == NULL)
return;
while (head->next != NULL)
head = head->next;
printf("List (Backward): ");
while (head != NULL)
{
printf("%d ", head->data);
head = head->prev;
}
printf("\n");
}
int main()
{
struct Node *head = NULL;
insertEnd(&head, 10);
insertEnd(&head, 20);
insertEnd(&head, 30);
displayForward(head);
displayBackward(head);
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\DSA\
9\" ; if ($?) { gcc 1.c -o 1 } ; if ($?) { .\1 }
List (Forward): 10 20 30
List (Backward): 30 20 10

Experiment 2 (Hash Table using Linear

Probing):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#define SIZE 10
int hashTable[SIZE];
void init()
{
for (int i = 0; i < SIZE; i++)
hashTable[i] = -1;
}
int hash(int key)
{
return key % SIZE;
}
void insertLinear(int key)
{
int index = hash(key);
int i = 0;
while (hashTable[(index + i) % SIZE] != -1 && i < SIZE)
i++;
if (i < SIZE)
hashTable[(index + i) % SIZE] = key;
else
printf("Hash table is full\n");
}
void display()
{
for (int i = 0; i < SIZE; i++)
printf("%d ", hashTable[i]);
printf("\n");
}
int main()
{
init();
 insertLinear(10);
insertLinear(20);
insertLinear(30);
insertLinear(25);
insertLinear(35);
display();
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\DSA\
9\" ; if ($?) { gcc 2.c -o 2 } ; if ($?) { .\2 }
10 20 30 -1 -1 25 35 -1 -1 -1
Experiment 3 (Hash Table using Quadratic
Probing):-
/*
Devansh Tiwari
24U030075
*/
#include <stdio.h>
#define SIZE 10
int hashTable[SIZE];
void init()
{
for (int i = 0; i < SIZE; i++)
hashTable[i] = -1;
}
int hash(int key)
{
return key % SIZE;
}
void insertQuadratic(int key)
{
int index = hash(key);
int i = 0;
while (i < SIZE)
{
int newIndex = (index + i * i) % SIZE;
if (hashTable[newIndex] == -1)
{
hashTable[newIndex] = key;
return;
}
i++;
}
printf("Hash table is full\n");
}
void display()
{
 for (int i = 0; i < SIZE; i++)
printf("%d ", hashTable[i]);
printf("\n");
}
int main()
{
init();
insertQuadratic(10);
insertQuadratic(20);
insertQuadratic(30);
insertQuadratic(25);
insertQuadratic(35);
display();
return 0;
}
Output:-
PS C:\Users\devu\2nd semester> cd "c:\Users\devu\2nd semester\DSA\
9\" ; if ($?) { gcc 3.c -o 3 } ; if ($?) { .\3 }
10 20 -1 -1 30 25 35 -1 -1 -1