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)

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

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

int main()

int 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

// 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();

// 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 left, int mid, int right)

int i, j, k;

int n1 = mid - left + 1;

int n2 = right - mid;

int *L = (int *)malloc(n1 * sizeof(int));

int *R = (int *)malloc(n2 * sizeof(int));

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

free(L);

free(R);

// Function to implement Merge Sort

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

// 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()

int 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

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

if (arr == NULL)

printf("Memory allocation failed\n");

return 1; // Exit if memory allocation fails

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();

// Calculate the time taken for one iteration

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

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

free(arr);

return 0;