DAA EXPERIMENTS

Insertion sort

#include <stdio.h>

int main() {
int key,length,i,j;
int arr[100];
printf("enter length of array:");
scanf("%d",&length);
printf("enter elements of array:\n");
for(i=0;i<length;i++){
scanf("%d",&arr[i]);
}
for(j=0;j<length;j++){
for(i=j;i>0;i--){
if(arr[i]<arr[i-1]){
key=arr[i];
arr[i]=arr[i-1];
arr[i-1]=key;
}
}
}
printf("after insertion sort\n");
for(i=0;i<length;i++){
printf("%d\n",arr[i]);
}

return 0;
}
Merge sort

#include <stdio.h>
#include <stdlib.h>
#include <conio.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 = (int *)malloc(n1 * sizeof(int));
int *R = (int *)malloc(n2 * sizeof(int));

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; // Initial index of first subarray

j = 0; // Initial index of second subarray
k = l; // Initial index of merged subarray
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 dynamically allocated memory

free(L);
free(R);
}

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

if (l < r) {
int m = l + (r - l) / 2; // Same as (l+r)/2, but avoids overflow for large l and
r
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}

void printArray(int arr[], int size) {

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

int main() {
int arr[] = {5, 8, 2, 1, 4, 6, 7, 9};
int arr_size = sizeof(arr) / sizeof(arr[0]);

printf("Before sorting:\n");
printArray(arr, arr_size);

mergeSort(arr, 0, arr_size - 1);

printf("After sorting:\n");
printArray(arr, arr_size);

getch();
return 0;
}
Kth smallest:

#include <stdio.h>
#include<conio.h>
#include<time.h>
void swap(int *a, int *b) {
int t = *a;
*a = *b;
*b = t;
}
int partition(int array[], int low, int high) {
int j;
int pivot = array[high];
int i = (low - 1);
for (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 kth_element(int array[],int k) {
printf("%d",array[k]);
}
void main() {
int k;
int data[] = {8, 7, 2, 1, 0, 9, 6};
int n = sizeof(data) / sizeof(data[0]);
quickSort(data, 0, n - 1);
printf("Enter the index: ");
scanf("%d",&k);
kth_element(data,k);
getch();
clrscr();
}
0/1 knapsack:

#include<stdio.h>
#include<conio.h>
int max(int a, int b){
if (a>b)
return a;
else
return b;
}
int knapsack(int W,int wt[],int val[], int n){
if(n==0||W==0)
return 0;
if(wt[n-1]>W)
return knapsack(W,wt,val,n-1);
else
return max(val[n-1]+knapsack(W-wt[n-1],wt,val,n-1), knapsack(W,wt,val,n-1));
}
int main(){
int wt[200],val[200],i,W,n;
printf("\nEnter the no of items: ");
scanf("%d",&n);
printf("\nEnter the total weight of the knapsack: ");
scanf("%d",&W);
for(i=0;i<n;i++)
{
printf("\nEnter the %dth item weight: ",i+1);
scanf("%d",&wt[i]);
}
for(i=0;i<n;i++)
{
printf("\nEnter the %dth item value: ",i+1);
scanf("%d",&val[i]);
}
printf("\nMaximum profit for the given values and weights is:
%d\n",knapsack(W,wt,val,n));
getch();
return 0;
}
Fractional Knapsack :
#include<stdio.h>
#include<conio.h>
void fknapsack(int n,float wt[],float pf[],float capacity){
float x[20],tp=0;
int i,j,u;
u=capacity;

for(i=0;i<n;i++){
x[i]=0.0;
}

for(i=0;i<n;i++){
if(wt[i] > u){
break;
}
else{
x[i]=1.0;
tp=tp+pf[i];
u=u-wt[i];
}
}

if(i<n){
x[i]=u/wt[i];
}
tp=tp+(x[i] * pf[i]);
printf("The result vector is:");
for(i=0;i<n;i++){
printf("%f\t",x[i]);
}
printf("Maximum Profit is: %f",tp);
}

void main(){
float capacity,weight[20],profit[20];
int n,i,j;
float ratio[20],temp;
printf("Enter no of Objects: ");
scanf("%d",&n);

printf("Enter capacity of knapsack: ");

scanf("%f",&capacity);

printf("Enter wts and profits of items:\n");

for(i=0;i<n;i++){
scanf("%f%f",&weight[i],&profit[i]);
}

for(i=0;i<n;i++){
ratio[i]=profit[i]/weight[i];
}

for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(ratio[i]<ratio[j]){
temp=ratio[j];
ratio[j]=ratio[i];
ratio[i]=temp;

temp=weight[j];
weight[j]=weight[i];
weight[i]=temp;

temp=profit[j];
profit[j]=profit[i];
profit[i]=temp;
}
}
}
fknapsack(n,weight,profit,capacity);
getch();
clrscr();
}
All Pair shortest path (floyd warshall):

#include <stdio.h>
#define V 4
#define INF 999999

void floydWarshall(int dist[][V])

{
int i, j, k;
for (k = 0; k < V; k++) {
for (i = 0; i < V; i++) {
for (j = 0; j < V; j++) {
if (dist[i][k] + dist[k][j] < dist[i][j]){
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
printSolution(dist);
}

void printSolution(int dist[][V])

{ int i,j;
printf(
"The following matrix shows the shortest distances"
" between every pair of vertices \n");
for ( i = 0; i < V; i++) {
for ( j = 0; j < V; j++) {
if (dist[i][j] ==INF){
printf("%s\t", "INF");
}
else{
printf("%d\t", dist[i][j]);
}
}
printf("\n");
}
}
int main()
{
int graph[V][V] = { { 0, 3, INF, 7 },
{ 8, 0, 2, INF },
{ 5, INF, 0, 1 },
{ 2, INF, INF, 0 } };

// Function call
clrscr();
floydWarshall(graph);

getch();
return 0;
}