Design and implement C/C++ Program to sort a given set of n integer elements using

Selection Sort method and compute its time complexity. Run the program for varied
values of n> 5000 and record the time taken to sort. Plot a graph of the time taken
versus n. The elements can be read from a file or can be generated using the random
number generator.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

// Function to perform selection sort on an array

void selectionSort(int arr[], int n)

int i, j, min_idx;

for (i = 0; i < n-1; i++)

min_idx = i; // Assume the current element is the minimum

for (j = i+1; j < n; j++)

if (arr[j] < arr[min_idx])

min_idx = j; // Update min_idx if a smaller element is found

// Swap the found minimum element with the current element

int temp = arr[min_idx];

arr[min_idx] = arr[i];

arr[i] = temp;

// Function to generate an array of random numbers

void generateRandomNumbers(int arr[], int n)

{
 int i;

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

arr[i] = rand() % 10000; // Generate random numbers between 0 and 9999

int main()

FILE *fp;

int n,i;

printf("Enter number of elements: ");

scanf("%d", &n); // Read the number of elements from the user

if (n <= 5000)

printf("Please enter a value greater than 5000\n");

return 1; // Exit if the number of elements is not greater than 5000

// Allocate memory for the array

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

if (arr == NULL)

printf("Memory allocation failed\n");

return 1; // Exit if memory allocation fails

fp = fopen("f.dat", "w");

if (fp == NULL) {

perror("Error opening file f.dat");

printf("Error: Unable to create QuickPlot.dat file for writing.\n");

 exit(1);

printf("File created successfully\n");

// Generate random numbers and store them in the array

generateRandomNumbers(arr, n);

// Measure the time taken to sort the array

clock_t start = clock();

selectionSort(arr, n);

clock_t end = clock();

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

fprintf(fp, "%d\n", arr[i]);

// Calculate and print the time taken to sort the array

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

printf("Time taken to sort %d elements: %f seconds\n", n, time_taken);

// Free the allocated memory

free(arr);

return 0;

Outputs:

Enter number of elements: 6000

Time taken to sort 6000 elements: 0.031000 seconds

********************************************************************

Enter number of elements: 7000

Time taken to sort 7000 elements: 0.034000 seconds

********************************************************************

Enter number of elements: 8000

Time taken to sort 8000 elements: 0.047000 seconds
********************************************************************

Enter number of elements: 9000

Time taken to sort 9000 elements: 0.052000 seconds

********************************************************************

Enter number of elements: 10000

Time taken to sort 10000 elements: 0.077000 seconds

Python code to plot graph:

import matplotlib.pyplot as plt

# data collected

n_values = [6000, 7000, 8000, 9000, 10000]

time_taken = [0.031000, 0.034000, 0.047000, 0.052000, 0.077000] #replace with actual times recorded

plt.plot(n_values, time_taken, marker='o')

plt.title('Selection Sort Time Complexity')

plt.xlabel('Number of Elements (n)')

plt.ylabel('Time taken (seconds)')

plt.grid(True)

plt.show()
Design and implement C/C++ Program to sort a given set of n integer elements using Merge Sort
method and compute its time complexity. Run the program for varied values of n> 5000, and record
the time taken to sort. Plot a graph of the time taken versus n. The elements can be read from a file
or can be generated using the random number generator.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

// Function to merge two sorted arrays

void merge(int arr[], int l, int m, int r)

int i, j, k;
int n1 = m - l + 1;

int n2 = r - m;

int L[n1],R[n2];

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

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

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

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

i = 0;

j = 0;

k = l;

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

// Function to implement Merge Sort

void mergeSort(int arr[], int l, int r)

if (l < r)

int m = l + (r - l) / 2;

mergeSort(arr, l, m);

mergeSort(arr, m + 1, r);

merge(arr, l, m, r);

// Function to generate random integers

void generateRandomArray(int arr[], int n)

int i;

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

arr[i] = rand() % 100000; // Generate random integers between 0 and 99999

int main()

FILE *fp;

int arr[10000],n,i;

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

scanf("%d", &n);

if (n <= 5000)

printf("Please enter a value greater than 5000\n");

return 1; // Exit if the number of elements is not greater than 5000

fp = fopen("mf.dat", "w");

if (fp == NULL) {

perror("Error opening file f.dat");

printf("Error: Unable to create QuickPlot.dat file for writing.\n");

exit(1);

printf("File created successfully\n");

generateRandomArray(arr, n);

// Repeat the sorting process multiple times to increase duration for timing

clock_t start = clock();

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

mergeSort(arr, 0, n - 1);

clock_t end = clock();

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

fprintf(fp, "%d\n", arr[i]);

// Calculate the time taken for one iteration

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

printf("Time taken to sort %d elements: %f seconds\n", n, time_taken);

return 0;

Design and implement C/C++ Program to sort a given set of n integer elements using Quick Sort
method and compute its time complexity. Run the program for varied values of n> 5000, and
record the time taken to sort. Plot a graph of the time taken versus n. The elements can be read
from a file or can be generated using the random number generator.

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

// Function to swap two elements

void swap(int* a, int* b)

int t = *a;

*a = *b;
 *b = t;

int partition(int a[], int l, int r) {

int i, j, temp;

int p;

p = a[l];

i = l;

j = r + 1;

do {

do {

i++;

} while (a[i] < p);

do {

j--;

} while (a[j] > p);

swap(&a[i], &a[j]);

while (i < j);

swap(&a[i], &a[j]);

swap(&a[l], &a[j]);

return j;

void quickSort(int a[], int l, int r) {

int s;

if (l < r) {

s = partition(a, l, r);

quickSort(a, l, s - 1);

quickSort(a, s + 1, r);

}
}

// Function to generate random numbers

void generateRandomNumbers(int arr[], int n)

int i;

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

arr[i] = rand() % 100000; // Generate random numbers between 0 and 99999

int main()

FILE *fp;

int i,n;

printf("Enter number of elements: ");

scanf("%d", &n); // Read the number of elements from the user

if (n <= 5000)

printf("Please enter a value greater than 5000\n");

return 1; // Exit if the number of elements is not greater than 5000

// Allocate memory for the array

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

if (arr == NULL)
 {

printf("Memory allocation failed\n");

return 1; // Exit if memory allocation fails

fp = fopen("qf.dat", "w");

if (fp == NULL) {

perror("Error opening file f.dat");

printf("Error: Unable to create QuickPlot.dat file for writing.\n");

exit(1);

printf("File created successfully\n");

// Generate random numbers and store them in the array

generateRandomNumbers(arr, n);

// Measure the time taken to sort the array

clock_t start = clock();

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

quickSort(arr, 0, n - 1);

clock_t end = clock();

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

fprintf(fp, "%d\n", arr[i]);

// Calculate and print the time taken to sort the array

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

printf("Time taken to sort %d elements: %f seconds\n", n, time_taken);

// Free the allocated memory

free(arr);

return 0;