CONTENTS

S.NO. NAME OF THE PROGRAM REMARKS

1 Recursive Program to implement Linear Search

2 Recursive Program to implement Binary Search

3 Write a program to implement heap sort.

4 Write a program to implement the merge sort.

5 Write a program to implement Selection Sort

6 Write a program to implement the insertion sort.

7 Write a program to implement the quick sort.

8 Write a program to implement the fractional knapsack

problem.
9 Write a program to implement traveling salesman
problem program.
10 Write a Program for creating a minimum spanning tree
from Kruskal's algorithm.
11 Write a program to implement the n-queen's problem.
 PROGRAM: - 1
RECURSIVE PROGRAM FOR LINEAR SEARCH.

int recSearch(int arr[], int l, int r, int x)

{
     if (r < l)
        return -1;
     if (arr[l] == x)
        return l;
     if (arr[r] == x)
        return r;
     return recSearch(arr, l+1, r-1, x);
}
  
int main()
{
    int arr[] = {12, 34, 54, 2, 3}, i;
    int n = sizeof(arr)/sizeof(arr[0]);
    int x = 3;
    int index = recSearch(arr, 0, n-1, x);
    if (index != -1)
       printf("Element %d is present at index %d", x, index);
    else
        printf("Element %d is not present", x);
    return 0;
}

OUTPUT-

Element 3 is present at index 4

 PROGRAM: - 2
RECURSIVE PROGRAM FOR BINARY SEARCH.
#include <stdio.h>
  
// A recursive binary search function. It returns location of x in
// given array arr[l..r] is present, otherwise -1
int binarySearch(int arr[], int l, int r, int x)
{
   if (r >= l)
   {
        int mid = l + (r - l)/2;
  
        // If the element is present at the middle itself
        if (arr[mid] == x)  return mid;
  
        // If element is smaller than mid, then it can only be present
        // in left subarray
        if (arr[mid] > x) return binarySearch(arr, l, mid-1, x);
  
        // Else the element can only be present in right subarray
        return binarySearch(arr, mid+1, r, x);
   }
  
   // We reach here when element is not present in array
   return -1;
}
  
int main(void)
{
   int arr[] = {2, 3, 4, 10, 40};
   int n = sizeof(arr)/ sizeof(arr[0]);
   int x = 10;
   int result = binarySearch(arr, 0, n-1, x);
   (result == -1)? printf("Element is not present in array")
                 : printf("Element is present at index %d", result);
   return 0;
}

OUTPUT-
Element is present at index 3
 PROGRAM: - 3

WRITE APROGRAM TO IMPLEMENT HEAP SORT.

#include<stdio.h>
void restoreHup(int*,int);
void restoreHdown(int*,int,int);
void main()
{
int a[20],n,i,j,k;
printf("
Enter the number of elements to sort : ");
scanf("%d",&n);

printf("Enter the elements : ");

for(i=1;i<=n;i++){
scanf("%d",&a[i]);
restoreHup(a,i);
}
j=n;
for(i=1;i<=j;i++)
{
int temp;
temp=a[1];
a[1]=a[n];
a[n]=temp;
n--;
restoreHdown(a,1,n);
}

n=j;

printf("Here is it... ");

for(i=1;i<=n;i++)
printf("%4d",a[i]);
}

void restoreHup(int *a,int i)

 {
int v=a[i];

while((i>1)&&(a[i/2]<v))
{
a[i]=a[i/2];
i=i/2;
}
a[i]=v;
}

void restoreHdown(int *a,int i,int n)

{
int v=a[i];
int j=i*2;
while(j<=n)
{
if((j<n)&&(a[j]<a[j+1]))
j++;
if(a[j]<a[j/2]) break;

a[j/2]=a[j];
j=j*2;
}
a[j/2]=v;
}

OUTPUT-
Enter the number of elements to sort : 3
Enter the elements :9
4
7
Here is it... 4 7 9
 PROGRAM: - 4
WRITE APROGRAM TO IMPLEMENT THE MERGE SORT.
#include <stdio.h>
#include <stdlib.h>
#define MAXARRAY 10
void mergesort(int a[], int low, int high);
int main(void) {
int array[MAXARRAY];
int i = 0;
/* load some random values into the array */
for(i = 0; i < MAXARRAY; i++)
array[i] = rand() % 100;
/* array before mergesort */
printf("Before :");
for(i = 0; i < MAXARRAY; i++)
printf(" %d", array[i]);
printf("\n");
mergesort(array, 0, MAXARRAY - 1);
/* array after mergesort */
printf("Mergesort :");
for(i = 0; i < MAXARRAY; i++)
printf(" %d", array[i]);
printf("\n");
return 0;}
void mergesort(int a[], int low, int high) {
int i = 0;
int length = high - low + 1;
int pivot = 0; int merge1 = 0; int merge2 = 0;
int working[length];
if(low == high)
return;
pivot = (low + high) / 2;
mergesort(a, low, pivot);
mergesort(a, pivot + 1, high);
for(i = 0; i < length; i++)
working[i] = a[low + i];
merge1 = 0;
 merge2 = pivot - low + 1;
for(i = 0; i < length; i++) {
if(merge2 <= high - low)
if(merge1 <= pivot - low)
if(working[merge1] > working[merge2])
a[i + low] = working[merge2++];
else a[i + low] = working[merge1++];
else a[i + low] = working[merge2++];
else a[i + low] = working[merge1++];
}
}

OUTPUT-

Before : 83 86 77 15 93 35 86 92 49 21
Mergesort : 15 21 35 49 77 83 86 86 92 93
 PROGRAM: - 5
WRITE A PROGRAM TO IMPLEMENT THE SELECTION SORT.

#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_idx;
  
    // One by one move boundary of unsorted subarray
    for (i = 0; i < n-1; i++)
    {
        // Find the minimum element in unsorted array
        min_idx = i;
        for (j = i+1; j < n; j++)
          if (arr[j] < arr[min_idx])
            min_idx = j;
  
        // Swap the found minimum element with the first element
        swap(&arr[min_idx], &arr[i]);
    }
}
  
/* Function to print an array */
void printArray(int arr[], int size)
{
    int i;
    for (i=0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}
  
// Driver program to test above functions
int main()
{
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr)/sizeof(arr[0]);
    selectionSort(arr, n);
    printf("Sorted array: \n");
    printArray(arr, n);
    return 0;
}

OUTPUT-

Sorted array:
11 12 22 25 64
 PROGRAM: - 6
WRITE APROGRAM TO IMPLEMENT THE INSERTION SORT.

#include <math.h>
#include <stdio.h>
  
/* Function to sort an array using insertion sort*/
void insertionSort(int arr[], int n)
{
    int i, key, j;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
  
        /* Move elements of arr[0..i-1], that are
          greater than key, to one position ahead
          of their current position */
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}
  
// A utility function to print an array of size n
void printArray(int arr[], int n)
{
    int i;
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
}
  
/* Driver program to test insertion sort */
int main()
{
    int arr[] = { 12, 11, 13, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    insertionSort(arr, n);
    printArray(arr, n);
  
    return 0;
}

Output:
5 6 11 12 13
 PROGRAM: - 7
WRITE A PROGRAM TO IMPLEMENT THE QUICK SORT.

#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];    // pivot
    int i = (low - 1);  // Index of smaller element
  
    for (int j = low; j <= high- 1; j++)
    {
        // If current element is smaller than the pivot
        if (arr[j] < pivot)
        {
            i++;    // increment index of smaller element
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}
  
/* The main function that implements QuickSort
 arr[] --> Array to be sorted,
  low  --> Starting index,
  high  --> Ending index */
void quickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        /* pi is partitioning index, arr[p] is now
           at right place */
        int pi = partition(arr, low, high);
  
        // Separately sort elements before
        // partition and after partition
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
  
/* Function to print an array */
void printArray(int arr[], int size)
{
    int i;
    for (i=0; i < size; i++)
        printf("%d ", arr[i]);
    printf("n");
}
  
// Driver program to test above functions
int main()
{
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr)/sizeof(arr[0]);
    quickSort(arr, 0, n-1);
    printf("Sorted array: n");
    printArray(arr, n);
    return 0;
}
Output:
Sorted array:
1 5 7 8 9 10
 PROGRAM: - 8
WRITE APROGRAM TO IMPLEMENT THE FRACTIONAL KNAPSACK PROBLEM.
#include <stdio.h>
int n=5;
int c[10]={12,1,2,1,4};
int v[10]={4,2,2,1,10};
int W=15;
void simple_fill()
{
int cur_w;
float tot_v;
int i,maxi;
int used[10];
for(i=0;i<n;++i)
used[i]=0;
cur_w=W;
while(cur_w>0)
{
maxi=-1;
for(i=0;i<n;++i)
if((used[i]==0)&&((maxi==-1)||((float)v[i]/c[i]>(float)v[maxi]/c[maxi])))
maxi=i;
used[maxi]=1;
cur_w-=c[maxi];
tot_v+=v[maxi];
if(cur_w>=0)
printf("Added object %d (%d$, %dKg) completly in the bag. Space left:
%d.\n",maxi+1,v[maxi],c[maxi],cur_w);
else
{
printf("Added %d%% (%d$, %dKg) of object %d in the bag.\n",(int)((1+
(float)cur_w/c[maxi])*100),v[maxi],c[maxi],maxi+1);
tot_v-=v[maxi];
tot_v+=(1+(float)cur_w/c[maxi])*v[maxi];
}
}
printf("Filled the bag with objects worth %.2f$.\n",tot_v);
}
int main(int argc,char *argv[])
{
simple_fill();
return 0;
}

OUTPUT-

Added object 5 (10$, 4Kg) completly in the bag. Space left: 11.
Added object 2 (2$, 1Kg) completly in the bag. Space left: 10.
Added object 3 (2$, 2Kg) completly in the bag. Space left: 8.
Added object 4 (1$, 1Kg) completly in the bag. Space left: 7.
Added 58% (4$, 12Kg) of object 1 in the bag.
Filled the bag with objects worth 17.33$.
 PROGRAM: - 9
WRITE APROGRAM TO IMPLEMENT TRAVELING SALESMAN PROBLEM
PROGRAM.

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <ctime>
using namespace std;
void createProfit(int profitMatrix[20][20]);
void createRoute(int currentRoute[20]);
int evaluateRoute(int currentRoute[20], const int profitMatrix[20][20]);
void tryRoute(int currentRoute[20], int bestRoute[20], const int profitMatrix[20][20]);
void swap(int &item1, int &item2);
int main()
{
// variables used
int profitMatrix[20][20];
int currentRoute[20];
int bestRoute[20];
int value=0;
   int max=0;
int i=0;
long int start;
int kount=0;

// create a random environment

createRoute(currentRoute);
createRoute(bestRoute);
createProfit(profitMatrix);

// seed the rand number generator

srand(time(0));

// loop for 60 CPU seconds

start=clock();
 while ((clock()-start)<60000)
{
   value=evaluateRoute(currentRoute, profitMatrix);
   tryRoute(currentRoute, bestRoute, profitMatrix);

   // display every 10000 cycles

   kount++;
   if (kount > 10000)
   {
    kount=0;
    cout<< "Current = " << evaluateRoute(currentRoute,profitMatrix) << "\t"
     << " Best = "   <<evaluateRoute(bestRoute,profitMatrix) << "\t"
 << " Time = "   << (clock()-start)/1000
 << "                 " << "\r";
   }
}

// output the best route found in the 60 seconds alloted

cout<< "\n\n";
cout<< "Profit is: " << evaluateRoute(bestRoute,profitMatrix) << "\n";
for (i=1; i<=19; i++)
{
 cout<< bestRoute[i] << "\n";
}
cout<< "\n\n";

// Grade the route - Hopefully you did great

cout<< "Grade is: " << int((evaluateRoute(bestRoute,profitMatrix)-
14000)*.025+60.00) << "\n";

return 0;
}

// tryRoute - tries a route.  You get to pick what route to try next.
//
//    inputs - currentRoute - the current route plan
//           - bestRoute    - the best route so far
//           - profitMatrix - the matrix used to calculate the profit for a route
//  
//   outputs - currentRoute - update this plan for you current route
//           - bestRoute    - Update this plan for the best route you have seen.
//           - profitMatrix - Changes to profitMatrix ARE NOT ALLOWED
void tryRoute(int currentRoute[20], int bestRoute[20], const int profitMatrix[20][20])
{

// variables
int planRoute[20];
int i;
int first;
int second;

static long int tries=0; // inializes to zero the first time only. (static)

// increments the number of tries.

tries++;

// copy the current route.

for (i=1; i<=19; i++)
{
 planRoute[i]=currentRoute[i];
}

// HINT: When is it best to start over?

//       When is it best to try small corrections to a known good route?
//       Maybe you could use the tries counter to see if you have spent
//         to much time on a specific route?

// 90% of the time start over, otherwise see if we can plan a better route
// based on the current route.
if (rand() < 32767*.90)
{
 // random route
 createRoute(planRoute);
}
else
 {

 // HINT:  Do I want to try small changes or massive changes?

 //        To change more than two cities put the following code in a loop!
 
 // flip two cities
 first=rand()%19+1;
 second=rand()%19+1;
 swap(planRoute[first],planRoute[second]);
}

// HINT:   Do I really want to save a bad route for further analysis?

//         Maybe sometimes, maybe never?

// save the current route reguardless of whether or not it is better

for (i=1; i<=19; i++)
{
 currentRoute[i]=planRoute[i];
}

// save the best one.

if (evaluateRoute(currentRoute,profitMatrix) >
evaluateRoute(bestRoute,profitMatrix))
{
 // reset the tries counter
 tries=0;

 // save current route to best route

 for (i=1; i<=19; i++)
 {
 bestRoute[i]=currentRoute[i];
 }
}
}

// evaluateRoute - evaluates a route.

//
//    inputs - route        - the current route plan
//           - profitMatrix - the matrix used to calculate the profit for a route
//  
//   outputs - the profit for the route provided.
//
int evaluateRoute(int route[20], const int profitMatrix[20][20])
{
int total=0;

for (int i=1; i<=18; i++)

{
 total=total+profitMatrix[route[i]][route[i+1]];
}
total=total+profitMatrix[19][1];
return total;
}

// createRoute - creates a route.

//
//    inputs - route        - the current route plan
//   outputs - route        - a random route.
void createRoute(int route[20])
{
int first;
int second;
int numb;
int i;

for (i=1; i<=19; i++)

{
 route[i]=i;
}

numb=rand()%10+5;
for (i=1; i<=numb; i++)
{
 first=rand()%19+1;
 second=rand()%19+1;
 swap(route[first],route[second]);
}
}

// createProfit - creates a random profit matrix.

//
//    inputs - profitMatrix - the current profit matrix
//  
//   outputs - profitMatrix - a random profit matrix.
//
void createProfit(int profitMatrix[20][20])
{
for (int i=1; i<=19; i++)
{
 for (int j=1; j<=19; j++)
 {
 profitMatrix[i][j]=rand()%800+100;
 }
}
}

// swap - exchanges two items

void swap(int &item1, int &item2)
{
int temp=item1;
item1=item2;
item2=temp;
}

OUTPUT-

Current = 9358 Best = 12614 Time = 55

Profit is: 12614

14
15
2
1
9
6
19
13
16
12
11
5
10
7
4
3
18
8
17

Grade is: 25
 PROGRAM: - 10
Write a Program for creating a minimum spanning tree from Kruskal's
algorithm.
// C program for Kruskal's algorithm to find Minimum Spanning Tree
// of a given connected, undirected and weighted graph
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
  
// a structure to represent a weighted edge in graph
struct Edge
{
    int src, dest, weight;
};
  
// a structure to represent a connected, undirected
// and weighted graph
struct Graph
{
    // V-> Number of vertices, E-> Number of edges
    int V, E;
  
    // graph is represented as an array of edges. 
    // Since the graph is undirected, the edge
    // from src to dest is also edge from dest
    // to src. Both are counted as 1 edge here.
    struct Edge* edge;
};
  
// Creates a graph with V vertices and E edges
struct Graph* createGraph(int V, int E)
{
    struct Graph* graph = new Graph;
    graph->V = V;
    graph->E = E;
  
    graph->edge = new Edge[E];
  
    return graph;
}
  
// A structure to represent a subset for union-find
struct subset
{
    int parent;
    int rank;
};
  
// A utility function to find set of an element i
// (uses path compression technique)
int find(struct subset subsets[], int i)
{
    // find root and make root as parent of i 
    // (path compression)
    if (subsets[i].parent != i)
        subsets[i].parent = find(subsets, subsets[i].parent);
  
    return subsets[i].parent;
}
  
// A function that does union of two sets of x and y
// (uses union by rank)
void Union(struct subset subsets[], int x, int y)
{
    int xroot = find(subsets, x);
    int yroot = find(subsets, y);
  
    // Attach smaller rank tree under root of high 
    // rank tree (Union by Rank)
    if (subsets[xroot].rank < subsets[yroot].rank)
        subsets[xroot].parent = yroot;
    else if (subsets[xroot].rank > subsets[yroot].rank)
        subsets[yroot].parent = xroot;
  
    // If ranks are same, then make one as root and 
    // increment its rank by one
    else
    {
        subsets[yroot].parent = xroot;
        subsets[xroot].rank++;
    }
}
  
// Compare two edges according to their weights.
// Used in qsort() for sorting an array of edges
int myComp(const void* a, const void* b)
{
    struct Edge* a1 = (struct Edge*)a;
    struct Edge* b1 = (struct Edge*)b;
    return a1->weight > b1->weight;
}
  
// The main function to construct MST using Kruskal's algorithm
void KruskalMST(struct Graph* graph)
{
    int V = graph->V;
    struct Edge result[V];  // Tnis will store the resultant MST
    int e = 0;  // An index variable, used for result[]
    int i = 0;  // An index variable, used for sorted edges
  
    // Step 1:  Sort all the edges in non-decreasing 
    // order of their weight. If we are not allowed to 
    // change the given graph, we can create a copy of
    // array of edges
    qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);
  
    // Allocate memory for creating V ssubsets
    struct subset *subsets =
        (struct subset*) malloc( V * sizeof(struct subset) );
  
    // Create V subsets with single elements
    for (int v = 0; v < V; ++v)
    {
        subsets[v].parent = v;
        subsets[v].rank = 0;
    }
  
    // Number of edges to be taken is equal to V-1
    while (e < V - 1 && i < graph->E)
    {
        // Step 2: Pick the smallest edge. And increment 
        // the index for next iteration
        struct Edge next_edge = graph->edge[i++];
  
        int x = find(subsets, next_edge.src);
        int y = find(subsets, next_edge.dest);
  
        // If including this edge does't cause cycle,
        // include it in result and increment the index 
        // of result for next edge
        if (x != y)
        {
            result[e++] = next_edge;
            Union(subsets, x, y);
        }
        // Else discard the next_edge
    }
  
    // print the contents of result[] to display the
    // built MST
    printf("Following are the edges in the constructed MST\n");
    for (i = 0; i < e; ++i)
        printf("%d -- %d == %d\n", result[i].src, result[i].dest,
                                                 result[i].weight);
    return;
}
  
// Driver program to test above functions
int main()
{
    /* Let us create following weighted graph
             10
        0--------1
        |  \     |
       6|   5\   |15
        |      \ |
        2--------3
            4       */
    int V = 4;  // Number of vertices in graph
    int E = 5;  // Number of edges in graph
    struct Graph* graph = createGraph(V, E);
  
  
    // add edge 0-1
    graph->edge[0].src = 0;
    graph->edge[0].dest = 1;
    graph->edge[0].weight = 10;
  
    // add edge 0-2
    graph->edge[1].src = 0;
    graph->edge[1].dest = 2;
    graph->edge[1].weight = 6;
  
    // add edge 0-3
    graph->edge[2].src = 0;
    graph->edge[2].dest = 3;
    graph->edge[2].weight = 5;
  
    // add edge 1-3
    graph->edge[3].src = 1;
    graph->edge[3].dest = 3;
    graph->edge[3].weight = 15;
  
    // add edge 2-3
    graph->edge[4].src = 2;
    graph->edge[4].dest = 3;
    graph->edge[4].weight = 4;
  
    KruskalMST(graph);
  
    return 0;
}

OUTPUT-

Following are the edges in the constructed MST

2 -- 3 == 4
0 -- 3 == 5
0 -- 1 == 10
 PROGRAM: - 11
WRITE APROGRAM TO IMPLEMENT THE N-QUEEN'S PROBLEM.

/* C/C++ program to solve N Queen Problem using

   backtracking */
#define N 4
#include <stdbool.h>
#include <stdio.h>
  
/* A utility function to print solution */
void printSolution(int board[N][N])
{
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++)
            printf(" %d ", board[i][j]);
        printf("\n");
    }
}
  
/* A utility function to check if a queen can
   be placed on board[row][col]. Note that this
   function is called when "col" queens are
   already placed in columns from 0 to col -1.
   So we need to check only left side for
   attacking queens */
bool isSafe(int board[N][N], int row, int col)
{
    int i, j;
  
    /* Check this row on left side */
    for (i = 0; i < col; i++)
        if (board[row][i])
            return false;
  
    /* Check upper diagonal on left side */
    for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
        if (board[i][j])
            return false;
  
    /* Check lower diagonal on left side */
    for (i = row, j = col; j >= 0 && i < N; i++, j--)
        if (board[i][j])
            return false;
  
    return true;
}
  
/* A recursive utility function to solve N
   Queen problem */
bool solveNQUtil(int board[N][N], int col)
{
    /* base case: If all queens are placed
      then return true */
    if (col >= N)
        return true;
  
    /* Consider this column and try placing
       this queen in all rows one by one */
    for (int i = 0; i < N; i++) {
        /* Check if the queen can be placed on
          board[i][col] */
        if (isSafe(board, i, col)) {
            /* Place this queen in board[i][col] */
            board[i][col] = 1;
  
            /* recur to place rest of the queens */
            if (solveNQUtil(board, col + 1))
                return true;
  
            /* If placing queen in board[i][col]
               doesn't lead to a solution, then
               remove queen from board[i][col] */
            board[i][col] = 0; // BACKTRACK
        }
    }
  
    /* If the queen cannot be placed in any row in
        this colum col  then return false */
    return false;
}
  
/* This function solves the N Queen problem using
   Backtracking. It mainly uses solveNQUtil() to 
   solve the problem. It returns false if queens
   cannot be placed, otherwise, return true and
   prints placement of queens in the form of 1s.
   Please note that there may be more than one
   solutions, this function prints one  of the
   feasible solutions.*/
bool solveNQ()
{
    int board[N][N] = { { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 } };
  
    if (solveNQUtil(board, 0) == false) {
        printf("Solution does not exist");
        return false;
    }
  
    printSolution(board);
    return true;
}
  
// driver program to test above function
int main()
{
    solveNQ();
    return 0;
}

Output: The 1 values indicate placements of queens

0 0 1 0
1 0 0 0
0 0 0 1
0 1 0 0