Binary Search:

#include <stdio.h>

#define s 10

int main()

int a[s],i,key,res;

int bsrch1(int *, int, int, int);

for(i=0;i<s;i++)

printf("Enter %d element\n",i+1);

scanf("%d",&a[i]);

printf("Enter the element for search");

scanf("%d",&key);

res=bsrch1(a,0,s-1,key);

if (res!=-1)

printf("Elmenet is found at %d location",res+1);

else

printf("Element is not found");

return 0;

int bsrch1(int *a, int l, int high, int key)

int mid;

if (l<=high)

mid=(l+high)/2; //mid=l+((high-l))/2);

if (a[mid]==key)

return mid;

else if (a[mid]>key)
 return bsrch1(a,l,mid-1,key);

else

return bsrch1(a,mid+1,high,key);

return -1;

MergeSort:

#include <stdio.h>

#include <stdlib.h>

#define n 10

void merge(int arr[], int left, int mid, int right)

int i, j, k;

int n1 = mid - left + 1;

int n2 = right - mid;

int *leftarr = (int *)malloc(n1 * sizeof(int));

int *rightarr = (int *)malloc(n2 * sizeof(int));

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

leftarr[i] = arr[left + i];

for (j = 0; j < n2; j++)

rightarr[j] = arr[mid + 1 + j];

i = 0;

j = 0;

k = left;

while (i < n1 && j < n2) {

if (leftarr[i] <= rightarr[j]) {

arr[k] = leftarr[i];
 i++;

} else {

arr[k] = rightarr[j];

j++;

k++;

while (i < n1) {

arr[k] = leftarr[i];

i++;

k++;

while (j < n2) {

arr[k] = rightarr[j];

j++;

k++;

free(leftarr);

free(rightarr);

void mergesort(int arr[], int left, int right)

if (left < right) {

int mid = left + (right - left) / 2;

mergesort(arr, left, mid);

mergesort(arr, mid + 1, right);

merge(arr, left, mid, right);

}
int main()

int arr[n] = {12, 11, 13, 5, 6, 7, 24, 67, 69, 10};

int i;

printf("\nBefore sorting: ");

for (i = 0; i < n; i++)

printf("%d ", arr[i]);

mergesort(arr, 0, n - 1);

printf("\nAfter sorting: ");

for (i = 0; i < n; i++)

printf("%d ", arr[i]);

return 0;

QuickSort:

#define s 10

#include <stdio.h>

int partition(int *a, int low, int high)

int pivot=a[low],i,j,t;

i=low;

j=high;

while(i<j)

while(a[i]<=pivot && i<=high-1)

i++;

while(a[j]>pivot && j>=low+1)

j--;

if (i<j)

{
 int t;

t=a[i];

a[i]=a[j];

a[j]=t;

t=a[low];

a[low]=a[j];

a[j]=t;

return j;

void quicksort(int *a, int low, int high)

int pivot;

if (low<high)

pivot=partition(a,low,high);

quicksort(a,low,pivot-1);

quicksort(a,pivot+1,high);

return;

int main()

int a[s],i;

for(i=0;i<s;i++)

printf("Enter %d element:",i+1);

scanf("%d",&a[i]);

}
 quicksort(a,0,s-1);

printf("After sorting:");

for(i=0;i<s;i++)

printf("%d\t",a[i]);

return 0;

MInMax:

#include<stdio.h>

#include<conio.h>

#define s 10

struct pair

int min;

int max;

};

struct pair getMinMax(int arr[], int low, int high)

struct pair minmax, mml, mmr;

int mid;

if(low==high)

minmax.max=arr[low];

minmax.min=arr[low];

return minmax;

if(high==low+1)

if(arr[low]>arr[high])

minmax.max=arr[low];

minmax.min=arr[high];
 }

else

minmax.max=arr[high];

minmax.min=arr[low];

return minmax;

mid = (low+high)/2;

mml=getMinMax(arr,low,mid);

mmr=getMinMax(arr,mid+1,high);

if(mml.min<mmr.min)

minmax.min=mml.min;

else

minmax.min=mmr.min;

if(mml.max>mmr.max)

minmax.max=mml.max;

else

minmax.max=mmr.max;

return minmax;

int main()

int arr[s],i;

struct pair minmax;

clrscr();

printf("\n Enter %d elements:",s);

for(i=0;i<s;i++)

scanf("%d",&arr[i]);

minmax = getMinMax(arr,0,s-1);

printf("\nMinimum element: %d",minmax.min);

getch();

return ;

Dijkstras Algorithm:

#include<limits.h>

#include<stdio.h>

#define V 9

int minDistance(int dist[], int sptSet[])

int min=INT_MAX, min_index;

int v;

for(v=0;v<V;v++)

if(sptSet[v]==0&&dist[v]<=min)

min=dist[v],min_index=v;

return min_index;

void printSolution(int dist[])

int i;

printf("Vertex\t\t Distance from source\n");

for(i=0;i<V;i++)

printf("%d\t\t\t\t%d\n",i,dist[i]);

void dijkstra(int graph[V][V], int src)

int dist[V];

int sptSet[V];

int i,count;

for(i=0;i<V;i++)

{
 dist[i]=INT_MAX;

sptSet[i]=0;

dist[src]=0;

for(count = 0; count<V; count++)

int u = minDistance(dist,sptSet), v;

sptSet[u]=1;

for(v = 0; v<V; v++)

if(!sptSet[v]&&graph[u][v]&&dist[u]!=INT_MAX&&dist[u]+graph[u][v]<dist[v])

dist[v]=dist[u]+graph[u][v];

printSolution(dist);

int main()

int i,j;

int graph[V][V];

for(i=0;i<V;i++)

for(j=0;j<V;j++)

printf("Enter %d to %d edge:",i+1,j+1);

scanf("%d",&graph[i][j]);

dijkstra(graph,0);

return 0;

}
Prims Algoritm:

#include<limits.h>

#include<stdio.h>

#define V 5

int minKey(int key[], int mstSet[])

int min = INT_MAX, min_index;

int v;

for(v=0;v<V;v++)

if(mstSet[v]==0&&key[v]<min)

min=key[v],min_index=v;

return min_index;

void printMST(int parent[], int graph[V][V])

int i;

printf("Edge \t Weight\n");

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

printf("%d-%d \t%d\n",graph[i][parent[i]]);

void primMST(int graph[V][V])

int parent[V];

int key[V];

int mstSet[V];

int i,count;

for(i=0;i<V;i++)

key[i]=INT_MAX;

mstSet[i]=0;
 }

key[0]=0;

parent[0]=-1;

for(count = 0; count<V; count++)

int u = minKey(key,mstSet), v;

mstSet[u]=1;

for(v = 0; v<V; v++)

if(graph[u][v]&&mstSet[v]==0&&graph[u][v]<key[v])

parent[v]=u,key[v]=graph[u][v];

printMST(parent,graph);

int main()

int i,j;

int graph[V][V];

for(i=0;i<V;i++)

for(j=0;j<V;j++)

printf("Enter %d to %d edge:",i+1,j+1);

scanf("%d",&graph[i][j]);

primMST(graph);

return 0;