EXPERIMENT -1

AIM: Write a program to implement Insertion sort in C.

SYNTAX CODE:

#include <stdio.h>

int main() {
int array[50];
int size;
printf("Enter the elements in the array: \n");
scanf("%d",&size);
for(int i=0;i<size;i++){
scanf("%d",&array[i]);
}
for (int i = 1; i < size; i++)
{ int key = array[i];
int j = i - 1;
while (key < array[j] && j >= 0)
{ array[j + 1] = array[j];
--j;
}
array[j + 1] = key;
}

printf("Sorted array in ascending order:\n");

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

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
1
OUTPUT:

Time Complexity:

● Best case: O(N)

● Average Case: O(N^2)
● Worst case: O(N^2)

Space Complexity:
● O(1)

NAME: DHRUV MISHRA

 EXPERIMENT - 2

AIM: Write a program to implement Selection sort in C.

SYNTAX CODE:

#include <stdio.h>
void swap(int* x, int* y)
{
int temp = *x;
*x = *y;
*y = temp;
}
int main()
{
int arr[50];
int n;
printf("Enter the elements in the array: \n");
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}
int i, j, min_idx;
for (i = 0; i < n - 1; i++)
{ min_idx = i;
for (j = i + 1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;

swap(&arr[min_idx], &arr[i]);
}
printf("Sorted array: \n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
return 0;
}

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
3
OUTPUT:

Time Complexity:

● Best case: O(N^2)

● Average Case: O(N^2)
● Worst case: O(N^2)

Space Complexity:
● O(1)

NAME: DHRUV MISHRA

 EXPERIMENT -3

AIM: Write a program to implement Quick sort in C.

SYNTAX CODE:

#include <stdio.h>
void swap(int* a, int* b)
{ int t = *a;
*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[50]; int
n;
printf("Enter the elements in the array: \n");
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}

NAME: DHRUV MISHRA

5
ROLL NO. : 2100910100068

NAME: DHRUV MISHRA

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

OUTPUT:

Time Complexity:

● Best case: O(N*log N)

● Average Case: O(N^2)
● Worst case: O(N*log N)

Space Complexity:
● O(1)

7
 EXPERIMENT -4

AIM: Write a program to implement Bubble sort in C.

SYNTAX CODE:

#include <stdio.h>
void swap(int* arr, int i, int j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
void bubbleSort(int arr[], int n)
{
int i, j;
for (i = 0; i < n - 1; i++)
for (j = 0; j < n - i - 1; j++)
if (arr[j] > arr[j + 1])
swap(arr, j, j + 1);
}
int main()
{
int arr[50];
int n;
printf("Enter the elements in the array: \n");
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}
bubbleSort(arr, n);
printf("Sorted array: ");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
return 0;
}

NAME:
NAME: DHRUV
DHRUV MISHRA
MISHRA
ROLL NO. : 2100910100068
OUTPUT:

Time Complexity:

● Best case: O(N)

● Average Case: O(N^2)
● Worst case: O(N^2)

Space Complexity:
● O(1)

9
 EXPERIMENT -5

AIM: Write a program to implement Merge sort in C.

SYNTAX CODE:

#include <stdio.h>
#include <stdlib.h>
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++;
}
NAME: DHRUV MISHRA
ROLL NO. : 2100910100068
}
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);
}
}

int main()
{
int arr[50];
int n;
printf("Enter the elements in the array: \n");
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}
mergeSort(arr, 0,n- 1);

printf("\nSorted array is \n");

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

OUTPUT:

1
1
 EXPERIMENT -6

AIM: Write a program to implement Heap sort in C.

SYNTAX 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);
}
}
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);
}
}
int main()

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
11
{
int arr[50];
int n;
printf("Enter the elements in the array: \n");
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}

heapSort(arr, n);
printf("Sorted array is\n");
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
}

OUTPUT:

Time Complexity:

● Best case: O(N*log N)

● Average Case: O(N*log N)
● Worst case: O(N*log N)

Space Complexity:
● O(1)

NAME: DHRUV MISHRA

 EXPERIMENT - 7

AIM: Write a program to implement Bucket sort in C.

SYNTAX CODE:

#include <stdio.h>
#include <stdlib.h>
#define NARRAY 7
#define NBUCKET 6
#define INTERVAL 10

struct Node
{ int data;
struct Node *next;
};
void BucketSort(int arr[]);
struct Node *InsertionSort(struct Node *list);
void print(int arr[]);
void printBuckets(struct Node *list);
int getBucketIndex(int value);

void BucketSort(int arr[])

{ int i, j;
struct Node **buckets;
buckets = (struct Node **)malloc(sizeof(struct Node *) * NBUCKET);
for (i = 0; i < NBUCKET; ++i) {
buckets[i] = NULL;
}
for (i = 0; i < NARRAY; ++i) {
struct Node *current;
int pos = getBucketIndex(arr[i]);
current = (struct Node *)malloc(sizeof(struct Node));
current->data = arr[i];
current->next = buckets[pos];
buckets[pos] = current;
}
for (i = 0; i < NBUCKET; i++) {
printf("Bucket[%d]: ", i);
printBuckets(buckets[i]);
printf("\n");
NAME: DHRUV MISHRA
ROLL NO. : 2100910100068
13
 }
for (i = 0; i < NBUCKET; ++i) {
buckets[i] = InsertionSort(buckets[i]);
}
printf("------------\n");
printf("Bucktets after sorting\n");
for (i = 0; i < NBUCKET; i++) {
printf("Bucket[%d]: ", i);
printBuckets(buckets[i]);
printf("\n");
}
for (j = 0, i = 0; i < NBUCKET; ++i) {
struct Node *node;
node = buckets[i];
while (node) {
arr[j++] = node->data;
node = node->next;
}
}
return;
}
struct Node *InsertionSort(struct Node *list)
{ struct Node *k, *nodeList;
if (list == 0 || list->next == 0)
{ return list;
}
nodeList = list;
k = list->next;
nodeList->next = 0;
while (k != 0)
{ struct Node *ptr;
if (nodeList->data > k->data)
{ struct Node *tmp;
tmp = k;
k = k->next;
tmp->next = nodeList;
nodeList = tmp;
continue;
}
for (ptr = nodeList; ptr->next != 0; ptr = ptr->next) {
if (ptr->next->data > k->data)

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
14
 break;
}
if (ptr->next != 0)
{ struct Node
*tmp; tmp = k;
k = k->next;
tmp->next = ptr->next;
ptr->next = tmp;
continue;
} else {
ptr->next = k;
k = k->next;
ptr->next->next = 0;
continue;
}
}
return nodeList;
}
int getBucketIndex(int value)
{ return value / INTERVAL;
}
void print(int ar[])
{ int i;
for (i = 0; i < NARRAY; ++i) {
printf("%d ", ar[i]);
}
printf("\n");
}

void printBuckets(struct Node *list)

{ struct Node *cur = list;
while (cur) {
printf("%d ", cur->data);
cur = cur->next;
}
}
int main(void) {
int array[NARRAY] = {42, 32, 33, 52, 37, 47, 51};

printf("Initial array: ");

print(array);

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
15
 printf("------------\n");

BucketSort(array);
printf("------------\n");
printf("Sorted array: ");
print(array);
return 0;
}

OUTPUT:

Time Complexity:

● Best case: O(N+k)

● Worst case: O(N^2)

Space Complexity:
● O(N+K)

NAME: DHRUV MISHRA

 EXPERIMENT - 8

AIM: Write a program to implement Radix sort in C.

SYNTAX CODE:

#include <stdio.h>
int getMax(int array[], int n)
{ int max = array[0];
for (int i = 1; i < n; i++)
if (array[i] > max)
max = array[i];
return max;
}
void countingSort(int array[], int size, int place)
{ int output[size + 1];
int max = (array[0] / place) % 10;

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

if (((array[i] / place) % 10) > max)
max = array[i];
}
int count[max + 1];
for (int i = 0; i < max; ++i)
count[i] = 0;
for (int i = 0; i < size; i++)
count[(array[i] / place) % 10]++;
for (int i = 1; i < 10; i++)
count[i] += count[i - 1];
for (int i = size - 1; i >= 0; i--)
{ output[count[(array[i] / place) % 10] - 1] =
array[i]; count[(array[i] / place) % 10]--;
}
for (int i = 0; i < size; i++)
array[i] = output[i];
}
void radixsort(int array[], int size)
{ int max = getMax(array, size);
for (int place = 1; max / place > 0; place *= 10)

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
17
countingSort(array, size, place);
}
int main()
{ int
arr[50]; int
n;
printf("Enter the elements in the array: \n");
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}
radixsort(arr, n);
for (int i = 0; i < n; ++i)
{ printf("%d ", arr[i]);
}
printf("\n");
}

OUTPUT:

Time Complexity:

● Best case: O(dN)

● Average Case: O(d*(n+b))
● Worst case: O(d*(n+b))

Space Complexity:
● O(N+d)

NAME: DHRUV MISHRA

 EXPERIMENT - 9

AIM: Write a program to implement Counting sort in C.

SYNTAX CODE:

#include <stdio.h>

void countingSort(int array[], int size)

{ int output[10];
int max = array[0];
for (int i = 1; i < size; i++)
{ if (array[i] > max)
max = array[i];
}
int count[10];
for (int i = 0; i <= max; ++i)
{ count[i] = 0;
}
for (int i = 0; i < size; i++) {
count[array[i]]++;
}
for (int i = 1; i <= max; i++)
{ count[i] += count[i - 1];
}
for (int i = size - 1; i >= 0; i--)
{ output[count[array[i]] - 1] =
array[i]; count[array[i]]--;
}
for (int i = 0; i < size; i++)
{ array[i] = output[i];
}
}
int main()
{ int
arr[50]; int
n;
printf("Enter the elements in the array: \n");
scanf("%d",&n);
for(int i=0;i<n;i++){

NAME: DHRUV MISHRA

19
ROLL NO. : 2100910100068

NAME: DHRUV MISHRA

 scanf("%d",&arr[i]);
}
countingSort(arr, n);
for (int i = 0; i < n; ++i)
{ printf("%d ", arr[i]);
}
printf("\n");
}

OUTPUT:

Time Complexity:

● Best case: O(N+k)

● Average Case: O(N+k)
● Worst case: O(N+k)

Space Complexity:
● O(N+k)

11
1
 EXPERIMENT - 10

AIM: Write a program to find Kth smallest element using quick sort in C.

SYNTAX CODE:

#include <stdio.h>
void swap(int* a, int* b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int partition(int A[], int l, int r)
{
int x = A[r];
int i = l-1;
for ( int j=l;j<=r-1;j++ )
{
if (A[j] <= x)
{
i = i + 1;
swap(&A[i], &A[j]);
}
}
swap(&A[i+1],& A[r]);
return i+1;
}
int kthSmallest(int A[], int left, int right, int K)
{
if (left == right)
return A[left];
int pos = partition(A, left, right);
int count = pos - left + 1;
if ( K == pos )
return A[pos];
else if ( K<pos )
kthSmallest(A, left, pos-1, K);
else
kthSmallest(A, pos+1, right, K) ;

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
21
}
int main()
{ int
arr[50]; int
n;
int k;
printf("Enter the elements in the array: \n");
scanf("%d",&n);
printf("Enter the value of K: \n");
scanf("%d",&k);
for(int i=0;i<n;i++){
scanf("%d",&arr[i]);
}
printf("The kth smallest element is : %d",kthSmallest(arr,0,n-1,k));
return 0;
}

OUTPUT:

Time Complexity:

● Best case: O(N)

● Worst case: O(N^2)

Space Complexity:
● O(N)

NAME: DHRUV MISHRA

22
ROLL NO. : 2100910100068

23
 EXPERIMENT - 11

AIM: Write a program to implement BST in C.

SYNTAX CODE:

#include <stdio.h>
#include <stdlib.h>

struct node
{ int data;
struct node *right_child;
struct node *left_child;
};
struct node* new_node(int x)
{ struct node *temp;
temp = malloc(sizeof(struct node));
temp->data = x;
temp->left_child = NULL;
temp->right_child = NULL;

return temp;
}

struct node* search(struct node * root, int x)

{ if (root == NULL || root->data == x)
return root;
else if (x > root->data)
return search(root->right_child, x);
else
return search(root->left_child, x);
}

struct node* insert(struct node * root, int x)

{ if (root == NULL)
return new_node(x);
else if (x > root->data)
root->right_child = insert(root->right_child, x);
else
root -> left_child = insert(root->left_child, x);

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
24
 return root;
}
struct node* find_minimum(struct node * root)
{ if (root == NULL)
return NULL;
else if (root->left_child != NULL)
return find_minimum(root->left_child);
return root;
}

struct node* delete(struct node * root, int x)

{ if (root == NULL)
return NULL;
if (x > root->data)
root->right_child = delete(root->right_child, x);
else if (x < root->data)
root->left_child = delete(root->left_child, x);
else {
if (root->left_child == NULL && root->right_child == NULL){
free(root);
return NULL;
}
else if (root->left_child == NULL || root->right_child == NULL)
{ struct node *temp;
if (root->left_child == NULL)
temp = root->right_child;
else
temp = root->left_child;
free(root);
return temp;
}
else {
struct node *temp = find_minimum(root->right_child);
root->data = temp->data;
root->right_child = delete(root->right_child, temp->data);
}
}
return root;
}

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
25
void inorder(struct node *root)
{ if (root != NULL)
{
inorder(root->left_child);
printf(" %d ", root->data);
inorder(root->right_child);
}
}

int main() {
struct node *root;
root = new_node(20);
insert(root, 5);
insert(root, 1);
insert(root, 25);
insert(root, 40);
insert(root, 45);
insert(root, 42);

inorder(root); printf("\
n");

root = delete(root, 1);

root = delete(root, 40);
root = delete(root, 45);
inorder(root); printf("\
n");
return 0;
}

OUTPUT:

NAME: DHRUV MISHRA

ROLL NO. : 2100910100068
26