JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

EXPERIMENT-1.1

AIM:- TO IMPLEMENT INSERTION SORT

SOURCE CODE:-

#include<stdio.h>
void insertionsort(int arr[],int len)
{ int temp=0;int j;
for(int i=1;i<len;i++)
{
temp=ar
r[i]; j=i-1;
while(j>=0&&arr[j]>temp)
{
arr[j+1]=ar
r[j]; j--;
}
arr[j+1]=temp;
}
}

int main()
{
printf("ENTER THE LENGTH OF THE ARRAY\n");
int len;
scanf("%d",&l
en); int arr[100];
for(int i=0;i<len;i+
+)
{
printf("ENTER %d element in the array :
\n",i+1); scanf("%d",&arr[i]);
}
insertionsort(arr,len);
for(int i=0;i<len;i++)
{
printf("%d ",arr[i]);
}
return 0;
}

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

OUTPUT:-

TIME COMPLEXITY:- BEST CASE-O(N) AVERAGE CASE-O(N^2) WORST CASE-O(N^2) SPACE COMPLEXITY-O(1)

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

EXPERIMENT-1.2

AIM:- TO IMPLEMENT SELECTION SORT

SOURCE CODE:-

#include <stdio.h> void

swap(int *a, int *b) { int
temp = *a; *a = *b;
*b = temp;
}
void selectionSort(int array[], int size)
{ for (int step = 0; step < size - 1; step++)
{ int min_idx = step; for (int i = step +
1; i < size; i++) { if (array[i] <
array[min_idx])
{
min_idx = i;
}
}
swap(&array[min_idx], &array[step]);
}
}

void printArray(int array[], int size)

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

int main() {
int data[] = {20, 12, 10, 15, 2}; int size =
sizeof(data) / sizeof(data[0]);
selectionSort(data, size); printf("Sorted array
in Acsending Order:\n");
printArray(data, size);
}

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

OUTPUT:-

TIME COMPLEXITY:-

BEST CASE-O(N^2)

AVERAGE CASE-O(N^2)

WORST CASE-O(N^2)

SPACE COMPLEXITY-O(1)

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

EXPERIMENT-1.3

AIM:- TO IMPLEMENT BUBBLE SORT

SOURCE CODE:-
#include <stdio.h>
void bubbleSort(int array[], int size) {

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

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

// swapping occurs if elements

// are not in the intended order
int temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
}
}
}
}

void printArray(int array[], int size)

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

int main() {
int data[] = {-2, 45, 0, 11, -9};

// find the array's length

int size = sizeof(data) / sizeof(data[0]);

bubbleSort(data, size);

printf("Sorted Array in Ascending Order:\n");

printArray(data, size);

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

OUTPUT:-

TIME COMPLEXITY:- BEST CASE-O(N) AVERAGE CASE-O(N^2) WORST CASE-O(N^2) SPACE COMPLEXITY-O(1)

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

EXPERIMENT-2.1

AIM:- TO IMPLEMENT MERGE SORT

SOURCE CODE:- #include

<stdio.h>
void merge(int arr[], int p, int q, int r)
{ int n1 = q - p + 1;
int n2 = r - q;

int L[n1], M[n2];

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

L[i] = arr[p + i]; for (int j
= 0; j < n2; j++) M[j] =
arr[q + 1 + j]; int i, j, k;
i = 0; j = 0; k = p;
while (i < n1 && j < n2) {
if (L[i] <= M[j]) { arr[k]
= L[i]; i++; } else {
arr[k] = M[j]; j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}

while (j < n2) {

arr[k] = M[j];
j++;
k++;
}
}

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

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

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++)
printf("%d ", arr[i]); printf("\n");
}

int main() {
int arr[] = {6, 5, 12, 10, 9, 1};
int size = sizeof(arr) / sizeof(arr[0]);

mergeSort(arr, 0, size - 1);

printf("Sorted array: \n");

printArray(arr, size);
}

OUTPUT:-

TIME COMPLEXITY:- BEST

CASE:- O(nlogn)
AVERAGE CASE:- O(nlogn) WORST CASE:- O(nlogn)

SPACE COMPLEXITY:- O(1)

EXPERIMENT-2.2

AIM:- TO IMPLEMENT RECURSIVE INSERTION SORT

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

SOURCE CODE:-

#include <stdio.h>
void insertionSortRecursive(int arr[], int n)
{
if (n <= 1)
{
return;
}

insertionSortRecursive(arr, n - 1);
int last = arr[n - 1]; int j = n - 2;
while (j >= 0 && arr[j] > last) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = last;
}

void printArray(int arr[], int size)

{
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main()
{
int arr[] = { 12, 11, 13, 5, 6 };
int n = sizeof(arr) / sizeof(arr[0]);

insertionSortRecursive(arr, n);
printArray(arr, n);

return 0;
}

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

OUTPUT:-

TIME COMPLEXITY:- O(n2 )

SPACE COMPLEXITY:- O(n)

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

EXPERIMENT-2.3

AIM:- TO IMPLEMENT HEAP SORT

SOURCE CODE:-

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

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

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 N)
{
for (int i = 0; i < N; i++)
printf("%d ", arr[i]);
printf("\n");
}

int main()
{
int arr[] = { 12, 11, 13, 5, 6, 7 };
int N = sizeof(arr) / sizeof(arr[0]);

heapSort(arr, N);
printf("Sorted array is\n"); printArray(arr, N);
}

OUTPUT:-

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

TIME COMPLEXITY:- BEST

CASE:- O(nlogn)
AVERAGE CASE:- O(nlogn) WORST CASE:- O(nlogn)

SPACE COMPLEXITY:- O(1)

EXPERIMENT-2.4

AIM:- TO IMPLEMENT QUICK SORT

SOURCE CODE:-
#include <stdio.h>
void swap(int* a, int* b)
{
int t = *a;

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

*a = *b;
*b = t;
}
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);
}
}

int main()
{
int arr[] = { 10, 7, 8, 9, 1, 5 };
int N = sizeof(arr) / sizeof(arr[0]);

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

quickSort(arr, 0, N - 1);
printf("Sorted array: \n"); for
(int i = 0; i < N; i++)
printf("%d ", arr[i]);
return 0;
}

OUTPUT:-

TIME COMPLEXITY:-

BEST CASE:- O(nlogn) AVERAGE CASE:- O(nlogn) WORST CASE:- O(n2)

SPACE COMPLEXITY:- O(n)

DESIGN AND ANALYSIS OF ALGORITHM

(KCS 553) PRASHANT YADAV 2100910100131