ADA ALGORITHMS:

PROGRAM 1:-
//Merge sort - Code
#include <stdio.h>

// function to sort the subsection a[i .. j] of the array a[]

void merge_sort(int i, int j, int a[], int aux[]) {
if (j <= i) {
return; // the subsection is empty or a single element
}
int mid = (i + j) / 2;

// left sub-array is a[i .. mid]

// right sub-array is a[mid + 1 .. j]

merge_sort(i, mid, a, aux); // sort the left sub-array

recursively
merge_sort(mid + 1, j, a, aux); // sort the right sub-array
recursively

int pointer_left = i; // pointer_left points to the beginning

of the left sub-array
int pointer_right = mid + 1; // pointer_right points to the
beginning of the right sub-array
 int k; // k is the loop counter

// we loop from i to j to fill each element of the final merged

array
for (k = i; k <= j; k++) {
if (pointer_left == mid + 1) { // left pointer has reached
the limit
aux[k] = a[pointer_right];
pointer_right++;
} else if (pointer_right == j + 1) { // right pointer has
reached the limit
aux[k] = a[pointer_left];
pointer_left++;
} else if (a[pointer_left] < a[pointer_right]) { // pointer
left points to smaller element
aux[k] = a[pointer_left];
pointer_left++;
} else { // pointer right points to smaller element
aux[k] = a[pointer_right];
pointer_right++;
}
}
 for (k = i; k <= j; k++) { // copy the elements from aux[] to
a[]
a[k] = aux[k];
}
}

int main() {
int a[100], aux[100], n, i, d, swap;

printf("Enter number of elements in the array:\n");

scanf("%d", &n);

printf("Enter %d integers\n", n);

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

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

merge_sort(0, n - 1, a, aux);

printf("Printing the sorted array:\n");

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

printf("%d\n", a[i]);
 return 0;
}

/*
SAMPLE INPUT AND OUTPUT:
Enter number of elements in the array:
6
Enter 6 integers
1
223
23
54
0
2
Printing the sorted array:
0
1
2
23
54
223
*/

PROGRAM 2:
/*PROGRAM TO IMPLEMENT THE QUICK SORT
ALGORITHM*/

#include<stdio.h>

void quicksort(int number[25],int first,int last)

{

int i, j, pivot, temp;

if(first<last)
{

pivot=first;

i=first;

j=last;

while(i<j)
{
 while(number[i]<=number[pivot]&&i<last)

i++;

while(number[j]>number[pivot])

j--;

if(i<j)
{
temp=number[i];
number[i]=number[j];
number[j]=temp;

temp=number[pivot];

number[pivot]=number[j];
 number[j]=temp;

quicksort(number,first,j-1);

quicksort(number,j+1,last);

int main()
{

int i, count, number[25];

printf("Enter some elements (Max. - 25): ");

scanf("%d",&count);

printf("Enter %d elements: ", count);

for(i=0;i<count;i++)
 scanf("%d",&number[i]);

quicksort(number,0,count-1);

printf("The Sorted Order is: ");

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

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

return 0;

/*
SAMPLE INPUT AND OUTPUT:
Enter some elements (Max. - 25): 6
Enter 6 elements: 23
4
55
6
77
0
The Sorted Order is: 0 4 6 23 55 77
*/

PROGRAM 3:

/* PROGRAM TO IMPLEMENT THE BST*/

#include<stdio.h>
#include<stdlib.h>
int main()
{
int c, first, last, middle, n, search, array[100];
printf("Enter number of elements:\n");
scanf("%d",&n);
printf("Enter %d Elements:\n", n);
for (c = 0; c < n; c++)
scanf("%d",&array[c]);
printf("Enter the value is to be Searched:\n");
scanf("%d", &search);
first = 0;
last = n - 1;
middle = (first+last)/2;
while (first <= last)
 {
if (array[middle] < search)
first = middle + 1;
else if (array[middle] == search) {
printf("%d is present at index %d.\n", search, middle+1);
break;
}
else
last = middle - 1;
middle = (first + last)/2;
}
if (first > last)
printf("Not found! %d is not present in the list.\n", search);
return 0;
}

/*
SAMPLE INPUT AND OUTPUT:
Enter number of elements:
5
Enter 5 Elements:
23
33
44
55
66
Enter the value is to be Searched:
7
Not found! 7 is not present in the list.

Enter number of elements:

6
Enter 6 Elements:
22
22
33
44
55
66
Enter the value is to be Searched:
66
66 is present at index 6.

*/
PROGRAM 4:
/*C Program to check whether the given graph is connected or
not*/
#include<stdio.h>
#include<conio.h>
int a[20][20],reach[20],n;
void dfs(int v) {
int i;
reach[v]=1;
for (i=1;i<=n;i++)
if(a[v][i] && !reach[i]) {
printf("\n %d->%d",v,i);
dfs(i);
}
}
int main()
{
int i,j,count=0;
printf("\n Enter number of vertices:");
scanf("%d",&n);
for (i=1;i<=n;i++)
{
reach[i]=0;
 for (j=1;j<=n;j++)
a[i][j]=0;
}
printf("\n Enter the adjacency matrix:\n");
for (i=1;i<=n;i++)
for (j=1;j<=n;j++)
scanf("%d",&a[i][j]);
dfs(1);
printf("\n");
for (i=1;i<=n;i++)
{
if(reach[i])
count++;
}
if(count==n)
printf("\n Graph is connected");
else
printf("\n Graph is not connected");
return 0;
}

/*
SAMPLE INPUT AND OUTPUT:

Enter number of vertices:3

Enter the adjacency matrix:

1
2
3
4
5
6
7
8
9

1->2
2->3

Graph is connected
------------------------------
*/
PROGRAM 5:

DFS_2.c

#include<stdio.h>
#include<stdlib.h>
#define MAXVALUE 100
#define initialValue 1
#define visitedValue 2
int node;
int adjacent[MAXVALUE][MAXVALUE];
int state[MAXVALUE];
void DFSTraversal();
void DFS(int vertex);
void createGraph();
int stack[MAXVALUE];
int topValue = -1;
void pushNode(int vertex);
int popNode();
int isEmpty();

main()
{
 createGraph();
DFSTraversal();
}
void DFSTraversal()
{
int vertex;
for(vertex=0; vertex<node; vertex++)
state[vertex]=initialValue;
printf("\nEnter start node for DFS : ");
scanf("%d",&vertex);
DFS(vertex);
printf("\n");
}
void DFS(int vertex)
{
int i;
pushNode(vertex);
while(!isEmpty())
{
vertex = popNode();
if(state[vertex]==initialValue)
{
printf("%d ",vertex);
 state[vertex]=visitedValue;
}
for(i=node-1; i>=0; i--)
{
if(adjacent[vertex][i]==1 &&
state[i]==initialValue)
pushNode(i);
}
}
}
void pushNode(int vertex)
{
if(topValue == (MAXVALUE-1))
{
printf("\n Error: Stack Overflow\n");
return;
}
topValue=topValue+1;
stack[topValue] = vertex;
}

int popNode()
{
int vertex;
 if(topValue == -1)
{
printf("\nStack Underflow\n");
exit(1);
}
else
{
vertex = stack[topValue];
topValue=topValue-1;
return vertex;
}
}

int isEmpty( )
{
if(topValue == -1)
return 1;
else
return 0;
}

void createGraph()
{
 int i,maxEdges,originNode,destinNode;
printf("\nEnter number of nodes : ");
scanf("%d",&node);
maxEdges=node*(node-1);
for(i=1;i<=maxEdges;i++)
{
printf("\nEnter edge %d( -3 -3 to quit ) : ",i);
scanf("%d %d",&originNode,&destinNode);
if( (originNode == -3) && (destinNode == -3) )
break;
if( originNode>= node || destinNode>= node ||
originNode<0 || destinNode<0)
{
printf("\nInvalid Edge/ Node!\n");
i--;
}
else
{
adjacent[originNode][destinNode] = 1;
}
}
}

/*
SAMPLE INPUT AND OUTPUT:

Enter number of nodes : 8

Enter edge 1( -3 -3 to quit ) : 0 2

Enter edge 2( -3 -3 to quit ) : 0 4

Enter edge 3( -3 -3 to quit ) : 1 1

Enter edge 4( -3 -3 to quit ) : 1 2

Enter edge 5( -3 -3 to quit ) : 1 5

Enter edge 6( -3 -3 to quit ) : 2 5

Enter edge 7( -3 -3 to quit ) : 2 7

Enter edge 8( -3 -3 to quit ) : 3 6

Enter edge 9( -3 -3 to quit ) : 4 8

Invalid Edge/ Node!

Enter edge 9( -3 -3 to quit ) : -3 -3

Enter start node for DFS : 0

02574

2 DFS_01

#include <stdio.h>
#include <stdlib.h>
int sourceV,Vertex,Edge,time,visited[10],Graph[10][10];
void DepthFirstSearch(int i)
{
int j;
visited[i]=1;
printf(" %d->",i++);
for(j=0;j<Vertex;j++)
{
if(Graph[i][j]==1&&visited[j]==0)
DepthFirstSearch(j);
}
}
int main()
{
int i,j,vertex1,vertex2;
printf("\t\t\tGraphs\n");
printf("Enter no. of edges:");
scanf("%d",&Edge);
printf("Enter no. of vertices:");
scanf("%d",&Vertex);
for(i=0;i<Vertex;i++)
{
for(j=0;j<Vertex;j++)
Graph[i][j]=0;
}
for(i=0;i<Edge;i++)
{
printf("Enter the edges in V1 V2 : ");
scanf("%d%d",&vertex1,&vertex2);
Graph[vertex1-1][vertex2-1]=1;
}
for(i=0;i<Vertex;i++)
{
for(j=0;j<Vertex;j++)
printf(" %d ",Graph[i][j]);
 printf("\n");
}
printf("Enter source Vertex: ");
scanf("%d",&sourceV);
DepthFirstSearch(sourceV-1);
return 0;
}

/*
SAMPLE INPUT AND OUTPUT:
Graphs
Enter no. of edges:5
Enter no. of vertices:2
Enter the edges in V1 V2 : 1 2
Enter the edges in V1 V2 : 2 3
Enter the edges in V1 V2 : 2 4
Enter the edges in V1 V2 : 2 5
Enter the edges in V1 V2 : 4 5
0 1
0 0
Enter source Vertex: 1 2
0->
*/
/* C Program to find whether a Directed Graph is Cyclic or not
*/

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

#define MAX 100

#define initial 1
#define visited 2
#define finished 3

int n; /*Number of vertices in the graph */

int adj[MAX][MAX];
void create_graph( );

int state[MAX];

void DF_Traversal();
void DFS(int v);

int main()
{
create_graph();
DF_Traversal();
return 0;
}/*End of main()*/

void DF_Traversal()
{
int v;

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

state[v] = initial;

DFS(0);/*start DFS from vertex 0*/

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

{
if(state[v]==initial)
DFS(v);
}
printf("\nGraph is Acyclic\n");
}/*End of DF_Traversal( )*/
void DFS(int v)
{
int i;
state[v] = visited;

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

{
if(adj[v][i]==1)
{
if(state[i]==initial)
DFS(i);
else if(state[i]==visited)
{
printf("\nBack edge (%d,%d) found\n", v,
i);
printf("\nGraph is cyclic\n");
exit(1);
}
}
}
state[v] = finished;
}/*End of DFS()*/

void create_graph()
{
int i,max_edges,origin,destin;

printf("\nEnter number of vertices : ");

scanf("%d",&n);
max_edges = n*(n-1);

for(i=1;i<=max_edges;i++)
{
printf("\nEnter edge %d( -1 -1 to quit ) : ",i);
scanf("%d %d",&origin,&destin);
if( (origin == -1) && (destin == -1) )
break;
if( origin >= n || destin >= n || origin<0 || destin<0)
{
printf("\nInvalid edge!\n");
i--;
}
else
{
adj[origin][destin] = 1;
}
}
}

/*
SAMPLE INPUT AND OUTPUT:

Enter number of vertices : 6

Enter edge 1( -1 -1 to quit ) : 0 1

Enter edge 2( -1 -1 to quit ) : 0 2

Enter edge 3( -1 -1 to quit ) : 0 3

Enter edge 4( -1 -1 to quit ) : 1 3

Enter edge 5( -1 -1 to quit ) : 3 4

Enter edge 6( -1 -1 to quit ) : 2 5

Enter edge 7( -1 -1 to quit ) : 5 4

Enter edge 8( -1 -1 to quit ) : -1 -1

Graph is Acyclic

*/

/* C Program to implement BFS Algorithm for Connected Graph

*/

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

#define MAX 100

#define initial 1
#define waiting 2
#define visited 3

int n; /*Number of vertices in the graph*/

int adj[MAX][MAX]; /*Adjacency Matrix*/
int state[MAX]; /*can be initial, waiting or visited*/

void create_graph();
void BF_Traversal();
void BFS(int v);

int queue[MAX], front = -1,rear = -1;

void insert_queue(int vertex);
int delete_queue();
int isEmpty_queue();

int main()
{
create_graph();
BF_Traversal();
return 0;

}/*End of main()*/

void BF_Traversal()
{
int v;
for(v=0; v<n; v++)
state[v] = initial;

printf("\nEnter starting vertex for Breadth First Search : ");

scanf("%d", &v);
 BFS(v);
}/*End of BF_Traversal()*/

void BFS(int v)
{
int i;

insert_queue(v);
state[v] = waiting;

while(!isEmpty_queue())
{
v = delete_queue( );
printf("%d ",v);
state[v] = visited;
for(i=0; i<n; i++)
{
/*Check for adjacent unvisited vertices */
if(adj[v][i] == 1 && state[i] == initial)
{
insert_queue(i);
state[i] = waiting;
}
 }
}
printf("\n");
} /*End of BFS()*/

void insert_queue(int vertex)

{
if(rear == MAX-1)
printf("\nQueue Overflow\n");
else
{
if(front == -1) /*If queue is initially empty */
front = 0;
rear = rear+1;
queue[rear] = vertex ;
}
}/*End of insert_queue()*/

int isEmpty_queue()
{
if(front == -1 || front > rear)
return 1;
else
 return 0;
} /*End of isEmpty_queue()*/

int delete_queue()
{
int del_item;
if(front == -1 || front > rear)
{
printf("\nQueue Underflow\n");
exit(1);
}

del_item = queue[front];
front = front+1;
return del_item;
} /*End of delete_queue() */

void create_graph()
{
int i,max_edges,origin,destin;

printf("\nEnter number of vertices : ");

scanf("%d",&n);
 max_edges = n*(n-1);

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

{
printf("\nEnter edge %d( -1 -1 to quit ) : ",i);
scanf("%d %d",&origin,&destin);

if((origin == -1) && (destin == -1))

break;

if(origin>=n || destin>=n || origin<0 || destin<0)

{
printf("\nInvalid edge!\n");
i--;
}
else
{
adj[origin][destin] = 1;
}
} /*End of for*/
} /*End of create_graph()*/
/*
SAMPLE INPUT AND OUTPUT:

Enter number of vertices : 5

Enter edge 1( -1 -1 to quit ) : 0 1

Enter edge 2( -1 -1 to quit ) : 0 2

Enter edge 3( -1 -1 to quit ) : 0 3

Enter edge 4( -1 -1 to quit ) : 1 3

Enter edge 5( -1 -1 to quit ) : 3 2

Enter edge 6( -1 -1 to quit ) : 4 4

Enter edge 7( -1 -1 to quit ) : -1 -1

Enter starting vertex for Breadth First Search : 0

0123

*/
/*PRIMS ALGO*/
#include<stdio.h>
#include<conio.h>

int n, cost[10][10];

void prim() {
int i, j, startVertex, endVertex;
int k, nr[10], temp, minimumCost = 0, tree[10][3];

/* For first smallest edge */

temp = cost[0][0];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (temp > cost[i][j]) {
temp = cost[i][j];
startVertex = i;
endVertex = j;
}
}
}
/* Now we have fist smallest edge in graph */
tree[0][0] = startVertex;
tree[0][1] = endVertex;
tree[0][2] = temp;
minimumCost = temp;

/* Now we have to find min dis of each vertex from either

startVertex or endVertex by initialising nr[] array
*/

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

if (cost[i][startVertex] < cost[i][endVertex])
nr[i] = startVertex;
else
nr[i] = endVertex;
}

/* To indicate visited vertex initialise nr[] for them to 100 */

nr[startVertex] = 100;
nr[endVertex] = 100;

/* Now find out remaining n-2 edges */

temp = 99;
for (i = 1; i < n - 1; i++) {
for (j = 0; j < n; j++) {
if (nr[j] != 100 && cost[j][nr[j]] < temp) {
temp = cost[j][nr[j]];
k = j;
}
}
/* Now i have got next vertex */
tree[i][0] = k;
tree[i][1] = nr[k];
tree[i][2] = cost[k][nr[k]];
minimumCost = minimumCost + cost[k][nr[k]];
nr[k] = 100;

/* Now find if k is nearest to any vertex

than its previous near value */

for (j = 0; j < n; j++) {

if (nr[j] != 100 && cost[j][nr[j]] > cost[j][k])
nr[j] = k;
}
temp = 99;
}
 /* Now i have the answer, just going to print it */
printf("\nThe min spanning tree is:-\n ");
for (i = 0; i < n - 1; i++) {
for (j = 0; j < 3; j++)
printf("%d\t", tree[i][j]);
printf("\n");
}

printf("\nMin cost : %d", minimumCost);

}

void main() {
int i, j;

printf("\nEnter the no. of vertices :");

scanf("%d", &n);

printf("\nEnter the costs of edges in matrix form :");

for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
scanf("%d", &cost[i][j]);
}
 printf("\nThe matrix is :\n ");
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf("%d\t", cost[i][j]);
}
printf("\n");
}
prim();
}

/*

SAMPLE INPUT AND OUTPUT:-

Enter the no. of vertices:- 3

Enter the costs of edges in matrix form:-

99 2 3
2 99 5
3 5 99

The matrix is:-

99 2 3
2 99 5
3 5 99

The min spanning tree is:-

0 1 2
2 0 3

Min cost:- 5

*/

/*Implementation of Kruskal's Algorithm*/

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
int i,j,k,a,b,u,v,n,ne=1;
int min,mincost=0,cost[9][9],parent[9];
int find(int);
int uni(int,int);
int main()
{
printf("\n\tImplementation of Kruskal's Algorithm\n");
printf("\nEnter the no. of vertices:");
scanf("%d",&n);
printf("\nEnter the cost adjacency matrix:\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
scanf("%d",&cost[i][j]);
if(cost[i][j]==0)
cost[i][j]=999;
}
}
printf("The edges of Minimum Cost Spanning Tree are\n");
while(ne < n)
{
for(i=1,min=999;i<=n;i++)
{
for(j=1;j <= n;j++)
{
if(cost[i][j] < min)
{
min=cost[i][j];
a=u=i;
 b=v=j;
}
}
}
u=find(u);
v=find(v);
if(uni(u,v))
{
printf("%d edge (%d,%d) =%d\n",ne++,a,b,min);
mincost +=min;
}
cost[a][b]=cost[b][a]=999;
}
printf("\n\tMinimum cost = %d\n",mincost);
return 0;
}

int find(int i)
{
while(parent[i])
 i=parent[i];
return i;
}

int uni(int i,int j)

{
if(i!=j)
{
parent[j]=i;
return 1;
}
return 0;
}

/*
SAMPLE INPUT AND OUTPUT:

Implementation of Kruskal's Algorithm

Enter the no. of vertices:3

Enter the cost adjacency matrix:
9
8
7
6
5
4
3
2
3
The edges of Minimum Cost Spanning Tree are
1 edge (3,2) =2
2 edge (3,1) =3

Minimum cost = 5

*/