INDEX

S.No Title Date

1 Implementation of an Array and deletion from a specified location 26/08/21

2 Implementation of a matrix ,and see wether it is a sparse matrix or not 26/08/21

3 Implementation of Linear Search 02/09/21

4 Implementation of Binary Search 02/09/21

5 Implementation of stack as an array 09/09/21

6 Implementation of stack as a linked list 16/09/21

7 Implementation of insertion , deletion on linked list. 07/10/21

8 Implementation of Queue. 21/10/21

9 Implementation of Queue as a linked list 27/10/21

10 Implementation of circular Queue with stack 11/11/21

11 Binary search tree insertion deletion and traversal 26/11/21

12 Implementation of heap sort 02/12/21

13 Implementation of insertion sort 09/12/21

14 Implementation of quick sort 09/12/21

15 Implementation of Selection sort 16/12/21

16 Implementation of Bubble sort 16/12/21

17 Implementation of Merge sort 23/12/21

18 Implementation of Radix/Bucket sort 23/12/21

 Experiment - 1

AIM: Implementation of an Array and deletion from a specified location.

SOFTWARE USED: VS code

CODE:

#include<stdio.h> #include<conio.h>
void insert_ele(int i,int arr[],int len)
{
int ele,loc;
printf("\n enter the element to be inserted \n");
scanf("%d",&ele);
printf("\n enter the location\n");
scanf("%d",&loc);
if(i==19)
{
printf("\nOverflow\n");
} else {
while(i>=loc)
{
arr[i+1]=arr[i]; i--;
} } arr[loc]=ele; len++;
printf("\n New array: ");
for(i=0;i<len;i++)
{
printf("%d ",arr[i]);
}
}
void delete_ele(int i,int arr[],int len)
{
int loc;
printf("enter the location of element to be deleted \n"); scanf("%d ",&loc);
if(len==0)
{ printf("\n Underflow");

} else {
for(i=loc;i<len;i++)
{ arr[i]=arr[i+1];

} len--;
printf("\n new array
is\n");
for(i=0;i<len;i++)
 {
printf("\t%d ",arr[i]);
}
}
} void main(){
int arr[20], i=0, len=0, ch; char choice;
printf("\nEnter number of elements you want to insert : "); scanf("%d",&len);
for(i=0;i<len;i++)
{
printf("enter the element %d :",i); scanf("%d",&arr[i]);
} i--; label:
printf("\n 1.To insert element,2.To delete \n");
scanf("%d",&ch);
switch(ch)
{ case 1: insert_ele(i,arr,len); break;
case 2: delete_ele(i,arr,len); break; default:
printf("\n Invalid operation\n");
break;
}
printf("\n press y to continue or any other key to quit : "); scanf("%s",&choice);
if(choice=='y'||choice=='Y')
{
goto label;
}
}

OUTPUT:
 EXPERIMENT - 2

AIM: Implementation of a matrix ,and see whether it is a sparse matrix or not.

SOFTWARE USED: VS code

CODE:

#include<stdio.h>
void main()
{
int matrix[10][10]; int i,j,m,n; int
sparse_counter=0;
printf("enter the orer of matrix : \n"); scanf("%d%d",&m,&n);
printf("Enter the elements of the matrix\n"); for(i=0;i<m;++i)
{
for(j=0;j<n;++j)
{
scanf("%d",&matrix[i][j]); if(matrix[i][j]==0)
{
++sparse_counter;
}

}
}
if(sparse_counter>((m*n)/2))
{
printf("The given matrix is sparse matrix!!!\n");
} else
{
printf("The given matrix is not a sparse matrix\n");
}
printf("There are %d no of zeroes.",sparse_counter); }

OUTPUT
 EXPERIMENT - 3

AIM: Implementation of a matrix, and see whether it is a sparse matrix or not.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h>

int main()
{
int arr[100],search,c,n; printf("Enter no of elements\n
"); scanf("%d",&n);
printf("Enter %d integer(s)\n",n);

for(c=0;c<n;c++)
{
scanf("%d",&arr[c]);
}
printf("Enter the element to search for \n"); scanf("%d",&search);

for(c=0;c<n;c++)
{
if(arr[c]==search)
{
printf("%d is present at location %d\n",search,c+1);
break;
}
} if(c==n)
{
printf("%d isnt present in the array.\n",search);
} return 0;
}

OUTPUT:
 EXPERIMENT - 4

AIM: Implementation of Binary Search.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h>
int main()
{
int c,first,l,last,middle,n,search,arr[100]; printf("Enter No of
elements \n"); scanf("%d",&n); printf("Enter %d
Integers\n",n); for(c=0;c<n;c++)
{
scanf("%d",&arr[c]);
}
printf("Enter the value to find :\n"); scanf("%d",&search);

first=0; last=n-1;
middle=(first+last)/2;

while(first<=last)
{
if(arr[middle<search])
{
first=middle+1;
}
else if(arr[middle]==search)
{
printf("%d found at location %d.\n",search,middle+1); break;
} else
{ last=middle-1;

middle=(first+last)/2;
} }
if(first>last)
{
printf("Not found ! %d isn't present in the list\n",search);
} return 0;
}
OUTPUT:
 EXPERIMENT - 5

AIM: Implementation of stack as an array.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h> int stack[100],choice,n,top,x,i;

void push(void); void pop(void);
void display(void); int main()
{

top=-1;
printf("\n Enter the size of STACK[MAX=100]:"); scanf("%d",&n);
printf("\n\t STACK OPERATIONS USING ARRAY");
printf("\n\t--------------------------------");
printf("\n\t 1.PUSH\n\t 2.POP\n\t 3.DISPLAY\n\t 4.EXIT"); do {
printf("\n Enter the Choice:"); scanf("%d",&choice);
switch(choice)
{ case 1: {
push(); break;
} case 2:
{ pop();
break;
} case 3: {
display(); break;
} case 4:
{
printf("\n\t EXIT POINT ");
break;
}
default:
{
printf ("\n\t Please Enter a Valid Choice(1/2/3/4)");
}

}
}
while(choice!=4);
return 0;
} void push() {
if(top>=n-1)
{
printf("\n\tSTACK is over flow");
 } else
{
printf(" Enter a value to be pushed:"); scanf("%d",&x);
top++; stack[top]=x;
}
} void pop()
{
if(top<=-1)
{
printf("\n\t Stack is under flow");
} else
{
printf("\n\t The popped elements is %d",stack[top]); top--;
}
} void display()
{
if(top>=0)
{
printf("\n The elements in STACK \n");
for(i=top; i>=0; i--) printf("\n%d",stack[i]);
printf("\n Press Next Choice");
} else
{
printf("\n The STACK is empty");
}

OUTPUT:
 EXPERIMENT - 6

AIM: Implementation of stack as a linked list.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h> #include<stdlib.h>
struct node
{
int data; struct node*next;

}; struct node*front; struct

node*rear; void insert(); void
delete(); void display(); void
main()
{
int choice;
while(choice!=4)
{
printf("\n********Main menu***********"); printf("\n1.insert an
element\n2.delete an element\n3.display\n4.exit the program\n");
printf("\n enter yoiur choice: ");
printf("\n============================");
scanf("%d",&choice);
switch(choice)
{ case 1:
insert(); break;
case 2: delete();
break; case 3:
display(); break;
case 4: exit(0);
break; default:
printf("\n enter a valid choice: \n");
}
}
}
void insert()
{
struct node*ptr; int item;
ptr=(struct node*)malloc(sizeof(struct node));
if(ptr==NULL)
{
printf("\nOVERFLOW\n");
 return; } else
{ printf("\n enter a
value?\n");
scanf("%d",&item);
ptr->data=item;
if(front==NULL)
{ front=ptr;
rear=ptr; front->next=NULL;
rear->next=NULL;
} else
{ rear->next=ptr;
rear=ptr;
rear->next=NULL;
}
}
}
void delete()
{
struct node*ptr;
if(front==NULL)
{
printf("\nUNDERFLOW");
return; } else {
ptr=front; front=front->next;
free(ptr);
}
} void display()
{
struct node*ptr; ptr=front;
if(front==NULL)
{
printf("\nEMPTY QUEUE\n");
} else {
printf("\n printing values...\n");
while(ptr!=NULL)
{
printf("%d ",ptr->data);
ptr=ptr->next;
}
}
}
OUTPUT:
 EXPERIMENT - 7
AIM: Implementation of insertion, deletion on linked list.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h> #include<stdlib.h>
struct node
{
int data; struct node*next;

}; struct node*front; struct

node*rear; void insert(); void
delete(); void display(); void
main()
{
int choice;
while(choice!=4)
{
printf("\n********Main menu***********"); printf("\n1.insert an
element\n2.delete an element\n3.display\n4.exit the program\n");
printf("\n enter yoiur choice: ");
printf("\n============================"); scanf("%d",&choice);
switch(choice)
{ case 1:
insert(); break;
case 2: delete();
break; case 3:
display(); break;
case 4: exit(0);
break; default:
printf("\n enter a valid choice: \n");
}
}
}
void insert()
{
struct node*ptr; int item;
ptr=(struct node*)malloc(sizeof(struct node));
if(ptr==NULL)
{
printf("\nOVERFLOW\n");
return; } else
{
 printf("\n enter a value?\n"); scanf("%d",&item);
ptr->data=item; if(front==NULL)
{ front=ptr;
rear=ptr; front->next=NULL;
rear->next=NULL;
} else
{ rear->next=ptr;
rear=ptr; rear->next=NULL;
}
}
}
void delete()
{
struct node*ptr;
if(front==NULL)
{
printf("\nUNDERFLOW");
return; } else {
ptr=front; front=front->next;
free(ptr);
}
} void display()
{
struct node*ptr; ptr=front;
if(front==NULL) {
printf("\nEMPTY QUEUE\n");
} else {
printf("\n printing values...\n");
while(ptr!=NULL)
{
printf("%d ",ptr->data); ptr=ptr->next;
}
}
}

OUTPUT:
 EXPERIMENT - 8
AIM: Implementation of Queue.

SOFTWARE USED: VS code

CODE:

#include<stdio.h> #include<stdlib.h>
struct node
{
int data; struct node *next;
}; struct node*head; void beginsert();
void lastinsert(); void randominsert();
void begin_delete(); void last_delete();
void random_delete(); void display();

void main()
{
int choice=0;
while(choice!=9)
{
printf("\n\n *****Main menu*****\n"); printf("\n choose one of the
option\n"); printf("\n-------------\n"); printf("\n1.Insert in
beginning\n2.insert at last\n3.Insert in the middle\n4.delete in the
beginning\n5.delete in the last\n6.delete in the middle\n7.display the list\n");
printf("\n Enter the choice \n"); scanf("\n %d",&choice);

switch(choice)
{ case 1:
beginsert(); break; case
2: lastinsert(); break;
case 3: randominsert();
break; case 4:
begin_delete();
break; case 5:
last_delete(); break;
case 6:
random_delete();
break; case 7:
display(); break;
case 8: exit(0);
break; default:
printf("\n Enter any valid choice\n");
 }
}
}
void beginsert()
{
struct node*ptr; int item;
ptr=(struct node*)malloc(sizeof(struct node*));
if(ptr==NULL)
{
printf("OVERFLOW");
} else {
printf("\n Enter the value");
scanf("%d",&item); ptr->data=item; ptr-
>next=head; head=ptr;
printf("\n Node inserted\n");
}
}
void lastinsert() {
struct node*ptr,*temp;
int item;
ptr=(struct node*)malloc(sizeof(struct node));
if(ptr==NULL)
{
printf("\nOVERFLOW\n");
} else {
printf("\n Enter the value?\n"); scanf("%d",&item); ptr->data=item;
if(head==NULL)
{
ptr->next=NULL;
head=ptr;
printf("\n Node inserted");
} else
{
temp=head;
while(temp->next!=NULL)
{
temp=temp->next;
}
temp->next=ptr; ptr->next=NULL;
printf("\n Node inserted");
}
}
}
void randominsert()
{
int i,loc,item; struct node*ptr,*temp;
ptr=(struct node*)malloc(sizeof(struct node));
 if(ptr==NULL)
{
printf("\n OVERFLOW");
} else {
printf("\n Enter the value\n");
scanf("%d",&item); ptr->data=item;
printf("\n Enter the location of the element to be inserted\n"); scanf("\n %d",&loc);
temp=head;
for(i=0;i<loc;i++)
{
temp=temp->next;
if(temp==NULL)
{
printf("\n can't insert");
return;
}
}
ptr->next=temp->next; temp->next=ptr;
printf("\n Node inserted");
}
} void display()
{
struct node*ptr; ptr=head;
if(ptr==NULL)
{
printf("\nNothing to print");
} else {
printf("\n Printing values. . . . .\n");
while(ptr!=NULL)
{
printf("%d ",ptr->data);
ptr=ptr->next;
}
}
} void begin_delete() {
struct node*ptr;
if(head==NULL)
{
printf("\n list is empty\n");
} else { ptr=head;
head=ptr->next;
free(ptr);
printf("\n Node deleted from the beginning ..\n");
}
}
void last_delete()
{
 struct node*ptr,*ptr1;
if(head==NULL)
{
printf("\n the list is empty\n");
}
else if(head->next==NULL)
{
head=NULL; free(head);
printf("\nOnly node of the list deleted ..\n");
} else {
ptr=head;
while(ptr->next!=NULL)
{ ptr1=ptr;
ptr=ptr->next;
}
ptr1->next=NULL;
free(ptr);
printf("\n Deleted node from the last..\n"); }
}
void random_delete()
{
struct node*ptr,*ptr1; int loc,i;
printf("\n Enter the location of the node after which you want to delete\n"); scanf("%d",&loc);
ptr=head; for(i=0;i<loc;i++)
{ ptr1=ptr; ptr=ptr-
>next;
if(ptr==NULL)
{
printf("\n can't delete");
return;
}
}
ptr1->next=ptr->next;
free(ptr);
printf("\n deleted nodes%d",loc+1); }
OUTPUT:
 EXPERIMENT - 9
AIM: Implementation of Queue as a linked list.

SOFTWARE USED: VS code.

CODE :

#include<stdio.h> #include<stdlib.h>
struct node
{
int data; struct node *next;
}; struct node*head; void
beginsert(); void lastinsert();
void randominsert(); void
begin_delete(); void
last_delete(); void
random_delete(); void display();

void main()
{
int choice=0;
while(choice!=9)
{
printf("\n\n *****Main menu*****\n"); printf("\n choose one of the
option\n");
printf("\n-------------\n"); printf("\n1.Insert in beginning\n2.insert at last\n3.Insert in the
middle\n4.delete in the beginning\n5.delete in the last\n6.delete in the middle\n7.display the list\n");
printf("\n Enter the choice \n"); scanf("\n %d",&choice);

switch(choice)
{ case 1:
beginsert(); break; case
2: lastinsert(); break;
case 3: randominsert();
break; case 4:
begin_delete();
break; case 5:
last_delete(); break;
case 6:
random_delete();
break; case 7:
display(); break;
case 8: exit(0);
break; default:
printf("\n Enter any valid choice\n");
}
 }
}
void beginsert()
{
struct node*ptr; int item;
ptr=(struct node*)malloc(sizeof(struct node*));
if(ptr==NULL)
{
printf("OVERFLOW");
} else {
printf("\n Enter the value");
scanf("%d",&item); ptr->data=item; ptr-
>next=head; head=ptr;
printf("\n Node inserted\n");
}
}
void lastinsert() {
struct node*ptr,*temp;
int item;
ptr=(struct node*)malloc(sizeof(struct node));
if(ptr==NULL)
{
printf("\nOVERFLOW\n");
} else {
printf("\n Enter the value?\n"); scanf("%d",&item);
ptr->data=item;
if(head==NULL)
{
ptr->next=NULL; head=ptr;
printf("\n Node inserted");
} else
{
temp=head;
while(temp->next!=NULL)
{
temp=temp->next;
}
temp->next=ptr; ptr->next=NULL;
printf("\n Node inserted");
}
}
}
void randominsert()
{
int i,loc,item; struct node*ptr,*temp;
ptr=(struct node*)malloc(sizeof(struct node));
if(ptr==NULL)
 {
printf("\n OVERFLOW");
} else {
printf("\n Enter the value\n");
scanf("%d",&item); ptr->data=item;
printf("\n Enter the location of the element to be inserted\n");
scanf("\n %d",&loc); temp=head;
for(i=0;i<loc;i++)
{
temp=temp->next;
if(temp==NULL)
{
printf("\n can't insert");
return;
}
}
ptr->next=temp->next; temp->next=ptr;
printf("\n Node inserted");
}
}
void display()
{
struct node*ptr; ptr=head;
if(ptr==NULL)
{
printf("\nNothing to print");
} else {
printf("\n Printing values. . . . .\n");
while(ptr!=NULL)
{
printf("%d ",ptr->data); ptr=ptr->next;
}
}
}
void begin_delete()
{
struct node*ptr;
if(head==NULL)
{
printf("\n list is empty\n");
} else { ptr=head;
head=ptr->next;
free(ptr);
printf("\n Node deleted from the beginning ..\n");
}
}
void last_delete()
{
struct node*ptr,*ptr1;
if(head==NULL)
{
printf("\n the list is empty\n");
}
else if(head->next==NULL)
{
head=NULL; free(head);
printf("\nOnly node of the list deleted ..\n");
} else {
ptr=head;
while(ptr->next!=NULL)
{ ptr1=ptr;
ptr=ptr->next;
}
ptr1->next=NULL;
free(ptr);
printf("\n Deleted node from the last..\n"); }
}
void random_delete()
{
struct node*ptr,*ptr1; int loc,i;
printf("\n Enter the location of the node after which you want to delete\n"); scanf("%d",&loc);
ptr=head; for(i=0;i<loc;i++)
{ ptr1=ptr; ptr=ptr-
>next;
if(ptr==NULL)
{
printf("\n can't delete");
return;
}
}
ptr1->next=ptr->next;
free(ptr);
printf("\n deleted nodes%d",loc+1); }
OUTPUT:
 EXPERIMENT 10
AIM: Implementation of circular Queue with stack.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h>
#include<stdlib.h> # define maxsize
5 void insert(); void delete(); void
display(); int front=-1,rear=-1; int
queue[maxsize]; void main()
{
int choice;
while(choice!=4)
{
printf("\n********Main menu********"); printf("\n
=====================\n");
printf("\n1.insert an element\n2.delete an element\n3.display list\n.4 exit");
printf("\n enter your choice?"); scanf("%d",&choice);
switch(choice)
{ case 1:
insert(); break;
case 2: delete();
break; case 3:
display(); break;
case 4: exit(0);
break; default:
printf("\n Enter valid choice\n");
}
}
}
void insert()
{
int item; printf("\n enter the elements\n");
scanf("\n %d",&item);
if(rear==maxsize-1)
{
printf("\n OVERFLOW\n");
return;
}
if(front==-1&&rear==-1)
{ front=0; rear=0;
} else { rear=rear+1;
}
queue[rear]=item;
 printf("\n Value inserted\n");
}
void delete()
{
int item; if(front==-1||front>rear)
{
printf("\nUNDERFLOEW\n");
return; } else
{ item=queue[front];
if(front==rear)
{ front=-1;
rear=-1; } else
{
front=front+1;
}
printf("\n value deleted\n");
}
} void display()
{
int i;
if(rear==-1)
{
printf("\n empty queue\n");
} else {
printf("\n printing values...\n");
for(i=front;i<=rear;i++)
{
printf("%d ",queue[i]);
}
}
}

OUTPUT:
 EXPERIMENT 11
AIM: Binary search tree insertion deletion and traversal.

SOFTWARE USED: VS code.

CODE:

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

struct node{ int key;

struct node *left, *right;
};
struct node *newNode(int item)
{
struct node*temp=(struct node*)malloc(sizeof(struct node)); temp->key=item; temp-
>left=temp->right=NULL;
return temp;
}
void inorder(struct node*root)
{
if(root!=NULL)
{ inorder(root->left); printf("%d
",root->key);

inorder(root->right);
}
}
struct node *find_Minimum(struct node *node)
{
struct node *current=node;
while(current&&current->left!=NULL)
{
current=current->left;
}
return current;
}

struct node *insert(struct node *node,int key)

{
if(node==NULL)
{
return newNode(key);
}
if(key<node->key)
 {
node->left=insert(node->left,key);
} else
{
node->right=insert(node->right,key);
} return node; }
struct node *deleteNode(struct node*root,int key)
{
if(root==NULL)
{
return root;
}
if(key<root->key)
{
root->left=deleteNode(root->left,key);
}
else if(key>root->key)
{
root->right=deleteNode(root->right,key);
} else
{
if(root->left==NULL)
{
struct node *temp=root->right;
free(root); return temp;
}
else if(root->right==NULL)
{
struct node *temp=root->left; free(root);
return temp;
} else
{
struct node *temp=find_Minimum(root->right); root->key=temp->key;
root->right=deleteNode(root->right,temp->key);
} }
return root;
}
int main() {
struct node*root=NULL; root=insert(root,8);
root=insert(root,3); root=insert(root,1);
root=insert(root,6); root=insert(root,7);
root=insert(root,10); root=insert(root,14);
root=insert(root,4); inorder(root);
 printf("\n after deleting 8\n");
root=deleteNode(root,8); inorder(root); return
0;

OUTPUT:
 EXPERIMENT - 12
AIM: Implementation of heap sort.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h>
void heapify(int a[],int n,int i)
{
int largest=i; int left=2*i+1; int right=2*i+2;
if(left<n&&a[left]>a[largest]) { largest=left;
}
if(right<n&&a[right]>a[largest])
{ largest=right;
} if(largest!=i) { int
temp=a[i]; a[i]=a[largest];
a[largest]=temp; heapify(a,n,largest);
}
}
void heapsort(int a[],int n)
{
for(int i=n/2-1;i>=0;i--)
{
heapify(a,n,i);
}
for(int i=n-1;i>=0;i--)
{ int temp=a[0];
a[0]=a[i]; a[i]=temp;

heapify(a,i,0);
}
}
void printarr(int arr[],int n)
{
for(int i=0;i<n;++i)
{ printf("%d",arr[i]); printf("
");
}
}

int main() {
int a[]={48,10,23,43.8,12,36}; int
n=sizeof(a)/sizeof(a[0]);
printarr(a,n); heapsort(a,n);
 printf("\n after sorting elements: "); printarr(a,n);
return 0;
}

OUTPUT:
 EXPERIMENT 13
AIM: Implementation of insertion sort.

Software used: VS code.

CODE:

#include<stdio.h> #include<conio.h>

void main()
{
int s,i,j,t,lst[50];
printf("Enter the size of the list: \n"); scanf("%d",&s);

printf("Enter the integer values: ",s); for(i=0;i<s;i++)

{
scanf("%d",&lst[i]);
}
for(i=1;i<s;i++)
{ t=lst[i];
j=i-1;
while((t<lst[j]) && (j>=0))
{
lst[j+1] = lst[j]; j=j-1;
} } lst[j+1]=t;
printf("List after sorting is :");
for(i=0;i<s;i++)
{
printf("%d ",lst[i]);
} getch();
}

OUTPUT:
 EXPERIMENT - 14
AIM: Implementation of quick sort.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h>
void swap(int *a,int *b)
{
int t=*a; *a=*b;
*b=t;
}
int partition(int array[],int low ,int high)
{
int pivot = array[high]; int i=(low-1);
for(int j=low;j<high;j++)
{
if(array[j]<=pivot)
{
i++;
swap(&array[i],&array[j]);
}
}
swap(&array[i+1],&array[high]);
return (i+1);
}
void quicksort(int array[],int low,int high)
{
if(low<high)
{
int pi=partition(array,low,high); quicksort(array,low,pi-1);
quicksort(array,pi+1,high);

}
}
void printarray(int array[],int size)
{
for(int i=0;i<size;++i)
{
printf("%d ",array[i]);
} printf("\n");
}
int main()
{
 int data[]={8,7,2,1,0,9,6}; int
n=sizeof(data)/sizeof(data[0]); printf("Unsorted array
"); printarray(data,n); quicksort(data,0,n-1);

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

return 0;

OUTPUT:
 EXPERIMENT - 15
AIM: Implementation of Selection sort.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h>

void swap(int *xp,int *yp)

{
int temp=*xp; *xp=*yp;
*yp=temp;
}
void selectionsort(int arr[],int n)
{
int i,j,min_id;
for(i=0;i<n-1;i++)
{ min_id=i;
for(j=i+1;j<n;j++) {
if(arr[j]<arr[min_id])
{ min_id=j; } }
swap(&arr[min_id],&arr[i]); }
}
void printarray(int arr[],int size)
{
int i;
for(i=0;i<size;i++)
{
printf("%d ",arr[i]);
} printf("\n");
}
int main() {
int arr[]={64,25,12,22,11}; int
n=sizeof(arr)/sizeof(arr[0]); selectionsort(arr,n);
printarray(arr,n);
return 0;
}

OUTPUT:
 EXPERIMENT - 16
AIM: Implementation of Bubble sort.

SOFTWARE USED: VS code.

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]) {

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

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

bubbleSort(data, size);

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

printArray(data, size); }

OUTPUT:
 EXPERIMENT 17
AIM: Implementation of Merge sort.

SOFTWARE USED: VS code.

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=1;
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 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);
 }
}
void printarrAY(int A[],int size)
{
int i;
for(i=0;i<size;i++)
{
printf("%d ", A[i]);
} printf("\n");
}
int main() {
int arr[]={12,11,13,5,6,7}; int
arr_size=sizeof(arr)/sizeof(arr[0]); printf("Given array is \n
"); printarrAY(arr,arr_size); mergesort(arr,0,arr_size-1);
printf("\n Sorted array is \n"); printarrAY(arr,arr_size);
return 0;
}

OUTPUT:
 EXPERIMENT - 18

AIM: Implemenation of Radix/Bucket sort.

SOFTWARE USED: VS code.

CODE:

#include<stdio.h> int largest(int a[])

{
int larger=a[0],i; for(i=1;i<10;i++) {
if(a[i]>larger)
{
larger=a[i];
} } return larger;
}
void radixsort(int a[], int n)
{
int bucket[10][10],bucket_count[10]; int i,j,k,r,NOP=0,
divisor=1,lar,pass; lar=largest(a);
while(lar>0)
{
NOP++; lar/=10;
}
for(pass=0;pass<NOP;pass++)
{
for(i=0;i<10;i++)
{
bucket_count[i]=0;
}
for(i=0;i<n;i++)
{
r=(a[i]/divisor)%10; bucket[r][bucket_count[r]]=a[i];
bucket_count[r]+=1;
}
i=0;
for(k=0;k<10;k++)
{
for(j=0;j<bucket_count[k];j++)
{
a[i]=bucket[k][j];
i++;
}
}
 divisor*=10;
printf("After pass %d : ",pass+1); for(i=0;i<n;i++)
{
printf("%d ",a[i]);
} printf("\n");
}
}
int main()
{
int i,n,a[10];
printf("enter the no of items to be sorted : ");
scanf("%d",&n); printf("Enter the items : ");
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
} radixsort(a,n); printf("Sorted items :
");
for(i=0;i<n;i++)
{
printf("%d ",a[i]);
} printf("\n");
return 0;
}

OUTPUT: