Practical 3

Set a
a) Sort a random array of n integers (accept the value of n from user) in ascending order by using
recursive Counting sort algorithm.
#include <stdio.h>

#include <stdlib.h>

int findMax(int arr[], int n) {

int max = arr[0];

for (int i = 1; i < n; i++) {

if (arr[i] > max) {

max = arr[i];

return max;

void recursiveCountingSort(int arr[], int n, int max, int depth) {

if (depth == 0) {

return;

int *count = (int *)calloc(max + 1, sizeof(int));

int *output = (int *)malloc(n * sizeof(int));

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

count[arr[i]]++;

for (int i = 1; i <= max; i++) {

count[i] += count[i - 1];

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

output[count[arr[i]] - 1] = arr[i];

count[arr[i]]--;

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

arr[i] = output[i];

}
free(count);

free(output);

recursiveCountingSort(arr, n, max, depth - 1);

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

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

printf("%d ", arr[i]);

printf("\n");

int main() {

int n;

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

scanf("%d", &n);

int arr[n];

printf("random array: ");

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

arr[i] = rand() % 100;

printf("%d ", arr[i]);

printf("\n");

int max = findMax(arr, n);

recursiveCountingSort(arr, n, max, 1);

printf(" count Sorted array: ");

printArray(arr, n);

return 0;

b) Sort a random array of n integers (accept the value of n from user) in ascending order
by using a recursive Merge sort algorithm.
 #include <stdio.h>

#include <stdlib.h>

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

int i, j, k;
int n1 = mid - left + 1;

int n2 = right - mid;

int L[n1], R[n2];

for (i = 0; i < n1; i++)

L[i] = arr[left + i];

for (j = 0; j < n2; j++)

R[j] = arr[mid + 1 + j];

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 n;

printf("Enter number of elements: ");

scanf("%d", &n);

int arr[n];

printf("random array: ");

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

arr[i] = rand() % 100;

printf("%d ", arr[i]);

printf("\n");

mergeSort(arr, 0, n - 1);

printf(" merge Sorted array: ");

printArray(arr, n);

return 0;

}
a)Sort a random array of n integers (create a random array of n integers) in ascending
order by using recursive Quick sort algorithm.
 #include <stdio.h>

#include <stdlib.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 - 1; 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");
}

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

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

arr[i] = rand() % 100;

int main() {

int n;

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

scanf("%d", &n);

int arr[n];

srand(time(0));

generateRandomArray(arr, n);

printf("random array: \n");

printArray(arr, n);

quickSort(arr, 0, n - 1);

printf(" quick Sorted array : \n");

printArray(arr, n);

return 0;

}
Set b
1) Read the data from the ‘employee.txt’ file and sort on age using Counting sort, Merge
sort, Quick sort and write the sorted data to another file 'sortedemponage.txt'.
 #include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define MAX_EMPLOYEES 100

#define MAX_NAME_LENGTH 50

#define MAX_AGE 100

typedef struct {

char name[MAX_NAME_LENGTH];

int age;

} Employee;

int readEmployees(const char *filename, Employee employees[])

FILE *file = fopen("employee.txt", "r");

if (file == NULL) {

printf("Error opening file: %s\n", filename);

return -1;

int i = 0;

while (fscanf(file, "%s %d", employees[i].name, &employees[i].age) != EOF && i < MAX_EMPLOYEES) {

i++;

fclose(file);

return i;

void writeEmployees(const char *filename, Employee employees[], int size) {

FILE *file = fopen("sortedemponage.txt", "w");

if (file == NULL) {

printf("Error opening file: %s\n", filename);

return;

}
for (int i = 0; i < size; i++) {

fprintf(file, "%s %d\n", employees[i].name, employees[i].age);

fclose(file);

void countingSort(Employee employees[], int n) {

Employee output[n];

int count[MAX_AGE + 1] = {0};

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

count[employees[i].age]++;

for (int i = 1; i <= MAX_AGE; i++) {

count[i] += count[i - 1];

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

output[count[employees[i].age] - 1] = employees[i];

count[employees[i].age]--;

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

employees[i] = output[i];

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

int n1 = mid - left + 1;

int n2 = right - mid;

Employee L[n1], R[n2];

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

L[i] = employees[left + i];

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

R[i] = employees[mid + 1 + i];

int i = 0, j = 0, k = left;

while (i < n1 && j < n2) {

if (L[i].age <= R[j].age) {

employees[k] = L[i];
i++;

} else {

employees[k] = R[j];

j++;

k++;

while (i < n1) {

employees[k] = L[i];

i++;

k++;

while (j < n2) {

employees[k] = R[j];

j++;

k++;

void mergeSort(Employee employees[], int left, int right) {

if (left < right) {

int mid = left + (right - left) / 2;

mergeSort(employees, left, mid);

mergeSort(employees, mid + 1, right);

merge(employees, left, mid, right);

int partition(Employee employees[], int low, int high) {

int pivot = employees[high].age;

int i = (low - 1);

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

if (employees[j].age < pivot) {

i++;

Employee temp = employees[i];

employees[i] = employees[j];

employees[j] = temp;
}

Employee temp = employees[i + 1];

employees[i + 1] = employees[high];

employees[high] = temp;

return (i + 1);

void quickSort(Employee employees[], int low, int high) {

if (low < high) {

int pi = partition(employees, low, high);

quickSort(employees, low, pi - 1);

quickSort(employees, pi + 1, high);

void copyEmployees(Employee source[], Employee destination[], int size) {

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

destination[i] = source[i];

int main() {

Employee employees[MAX_EMPLOYEES];

Employee tempEmployees[MAX_EMPLOYEES];

int numEmployees = readEmployees("employee.txt", employees);

if (numEmployees == -1) {

return 1;

copyEmployees(employees, tempEmployees, numEmployees);

countingSort(tempEmployees, numEmployees);

writeEmployees("sortedemponage_counting.txt", tempEmployees, numEmployees);

printf("Data sorted by Counting Sort written to 'sortedemponage_counting.txt'\n");

copyEmployees(employees, tempEmployees, numEmployees);

mergeSort(tempEmployees, 0, numEmployees - 1);

writeEmployees("sortedemponage_merge.txt", tempEmployees, numEmployees);

printf("Data sorted by Merge Sort written to 'sortedemponage_merge.txt'\n");

copyEmployees(employees, tempEmployees, numEmployees);

quickSort(tempEmployees, 0, numEmployees - 1);

writeEmployees("sortedemponage_quick.txt", tempEmployees, numEmployees);

printf("Data sorted by Quick Sort written to 'sortedemponage_quick.txt'\n");

return 0;

}
2) Read the data from the file and sort on names in alphabetical order (use strcmp)
using Counting sort, Merge sort, Quick sort and write the sorted data to another file
'sortedemponname.txt'.
 #include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define MAX_EMPLOYEES 100

#define MAX_NAME_LENGTH 50

typedef struct {

char name[MAX_NAME_LENGTH];

int age;

} Employee;

int readEmployees(const char *filename, Employee employees[])

FILE *file = fopen("employee.txt", "r");

if (file == NULL) {

printf("Error opening file: %s\n", filename);

return -1;

int i = 0;

while (fscanf(file, "%s %d", employees[i].name, &employees[i].age) != EOF && i < MAX_EMPLOYEES) {

i++;

fclose(file);

return i;

void writeEmployees(const char *filename, Employee employees[], int size) {

FILE *file = fopen("sortedemponname.txt", "w");

if (file == NULL) {

printf("Error opening file: %s\n", filename);

return;

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

fprintf(file, "%s %d\n", employees[i].name, employees[i].age);

fclose(file);
}

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

int n1 = mid - left + 1;

int n2 = right - mid;

Employee L[n1], R[n2];

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

L[i] = employees[left + i];

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

R[i] = employees[mid + 1 + i];

int i = 0, j = 0, k = left;

while (i < n1 && j < n2) {

if (strcmp(L[i].name, R[j].name) <= 0) {

employees[k] = L[i];

i++;

} else {

employees[k] = R[j];

j++;

k++;

while (i < n1) {

employees[k] = L[i];

i++;

k++;

while (j < n2) {

employees[k] = R[j];

j++;

k++;

void mergeSort(Employee employees[], int left, int right) {

if (left < right) {

int mid = left + (right - left) / 2;

mergeSort(employees, left, mid);

mergeSort(employees, mid + 1, right);

merge(employees, left, mid, right);

int partition(Employee employees[], int low, int high) {

Employee pivot = employees[high];

int i = (low - 1);

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

if (strcmp(employees[j].name, pivot.name) < 0) {

i++;

Employee temp = employees[i];

employees[i] = employees[j];

employees[j] = temp;

Employee temp = employees[i + 1];

employees[i + 1] = employees[high];

employees[high] = temp;

return (i + 1);

void quickSort(Employee employees[], int low, int high) {

if (low < high) {

int pi = partition(employees, low, high);

quickSort(employees, low, pi - 1);

quickSort(employees, pi + 1, high);

void countingSort(Employee employees[], int n) {

int count[26] = {0};

Employee output[n];

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

count[employees[i].name[0] - 'A']++;

for (int i = 1; i < 26; i++) {

count[i] += count[i - 1];

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

output[count[employees[i].name[0] - 'A'] - 1] = employees[i];

count[employees[i].name[0] - 'A']--;

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

employees[i] = output[i];

int main() {

Employee employees[MAX_EMPLOYEES];

int numEmployees = readEmployees("employee.txt", employees);

if (numEmployees == -1) {

return 1;

countingSort(employees, numEmployees);

writeEmployees("sortedemponname.txt", employees, numEmployees);

printf("Data sorted by Counting Sort written to 'sortedemponname.txt'\n");

mergeSort(employees, 0, numEmployees - 1);

writeEmployees("sortedemponname.txt", employees, numEmployees);

printf("Data sorted by Merge Sort written to 'sortedemponname.txt'\n");

quickSort(employees, 0, numEmployees - 1);

writeEmployees("sortedemponname.txt", employees, numEmployees);

printf("Data sorted by Quick Sort written to 'sortedemponname.txt'\n");

return 0;

Set c
A) What modification is required to Merge sort to sort the integers in descending order?
 #include <stdio.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;

int j = 0;

int 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 arr[] = {12, 11, 13, 5, 6, 7};

int arrSize = sizeof(arr) / sizeof(arr[0]);

printf("Given array is \n");

printArray(arr, arrSize);

mergeSort(arr, 0, arrSize - 1);

printf("\nSorted array in descending order is \n");

printArray(arr, arrSize);

return 0;

}
b) Compare the system time taken by Merge sort and bubble sort by using time
command on a random array of integers of size 10000 or more.
 #include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define SIZE 10000

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

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

arr[i] = rand() % 10000; // Random integers from 0 to 9999

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

for (int i = 0; i < size - 1; i++) {

for (int j = 0; j < size - i - 1; j++) {

if (arr[j] > arr[j + 1]) {

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

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 copyArray(int dest[], int src[], int size) {

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

dest[i] = src[i];

int main() {

int arr[SIZE];

srand(time(NULL));

generateRandomArray(arr, SIZE);

copyArray(arrCopy, arr, SIZE);

clock_t start = clock();

bubbleSort(arrCopy, SIZE);

clock_t end = clock();

double bubbleSortTime = ((double)(end - start)) / CLOCKS_PER_SEC;

copyArray(arrCopy, arr, SIZE);

start = clock();

mergeSort(arrCopy, 0, SIZE - 1);

end = clock();

double mergeSortTime = ((double)(end - start)) / CLOCKS_PER_SEC;

printf("Time taken by Bubble Sort: %f seconds\n", bubbleSortTime);

printf("Time taken by Merge Sort: %f seconds\n", mergeSortTime);

return 0;