ADA Lab Manual
ADA Lab Manual
DEPARTMENT OF CSE/IT
Lab Manual
(2023-24)
*Analysis and Design of Algorithms Lab*
(ECSDEADA001P)
Submitted to Submitted By
Prof. Name
Designation Enl. No.
INDEX
S. NO LIST OF EXPRIEMENTS DATE REMARKS SINATURE
Working
The binary search algorithm works by comparing the element to be searched by the middle
element of the array and based on this comparison follows the required procedure.
Case 2 − element > middle, search for the element in the sub-array starting from middle+1 index
to n.
Case 3 − element < middle, search for element in the sub-array starting from 0 index to middle -
1.
ALGORITHM
Program
#include<stdio.h>
intiterativeBinarySearch(int array[],intstart_index,intend_index,int element){
while(start_index<=end_index){
int middle =start_index+(end_index-start_index)/2;
if(array[middle]== element)
return middle;
if(array[middle]< element)
start_index= middle +1;
else
end_index= middle -1;
}
return-1;
}
int main(void){
intarray[]={1,4,7,9,16,56,70};
int n =7;
int element =16;
intfound_index=iterativeBinarySearch(array,0, n-1, element);
if(found_index==-1){
printf("Element not found in the array ");
}
else{
printf("Element found at index : %d",found_index);
}
return0;
}
Output
Element found at index: 4
Program
#include<stdio.h>
intrecursiveBinarySearch(int array[],intstart_index,intend_index,int element){
if(end_index>=start_index){
int middle =start_index+(end_index-start_index)/2;
if(array[middle]== element)
return middle;
if(array[middle]> element)
returnrecursiveBinarySearch(array,start_index, middle-1, element);
returnrecursiveBinarySearch(array, middle+1,end_index, element);
}
return-1;
}
int main(void){
intarray[]={1,4,7,9,16,56,70};
int n =7;
int element =9;
intfound_index=recursiveBinarySearch(array,0, n-1, element);
if(found_index==-1){
printf("Element not found in the array ");
}
else{
printf("Element found at index : %d",found_index);
}
return0;
}
Output
Element found at index: 3
Experiment No: 2
#include<stdio.h>
#include<conio.h>
void merge(int[],int,int,int);
void mergesort(int[], int,int);
void merge(int a[25], int low, int mid, int high)
{
int b[25],h,i,j,k;
h=low;
i=low;
j=mid+1;
while((h<=mid)&&(j<=high))
{
if(a[h]<a[j])
{
b[i]=a[h];
h++;
}
else
{
b[i]=a[j];
j++;
}
i++;
}
if(h>mid)
{
for(k=j;k<=high;k++)
{
b[i]=a[k];
i++;
}
}
else
{
for(k=h;k<=mid;k++)
{
b[i]=a[k];
i++;
}
}
for(k=low;k<=high;k++)
{
a[k]=b[k];
}
}
void mergesort(int a[25],int low,int high)
{
int mid;
if(low<high)
{
mid=(low+high)/2;
mergesort(a,low,mid);
mergesort(a,mid+1,high);
merge(a, low,mid,high);
}
}
void main()
{
int a[25],i,n;
clrscr();
printf("\n Enter the size of the elements to be sorted:");
scanf("%d",&n);
printf("\n Enter the elements to sort:");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
printf("\n The Elements before sorting are:");
for(i=0;i<n;i++)
printf("%d\t",a[i]);
mergesort(a, 0,n-1);
printf("\n The elements after sorting are:");
for(i=0;i<n;i++)
printf("%d\t",a[i]);
getch();
}
Output:
Experiment No: 3
Program:
#include<stdio.h>
#include<conio.h>
void qsort(int [],int,int);
int partition(int [],int,int);
void qsort(int a[],int first,int last)
{
int j;
if(first<last)
{
j=partition(a,first,last+1);
qsort(a,first,j-1);
qsort(a,j+1,last);
}
}
int partition(int a[],int first,int last)
{
int v=a[first];
int i=first;
int j=last;
int temp=0;
do
{
do
{
i++;
}while(a[i]<v);
do
{
j--;
}while(a[j]>v);
if(i<j)
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}while(i<j);
a[first]=a[j];
a[j]=v;
return j;
}
int main()
{
int a[40],i,n;
clrscr();
printf("\n Enter the no of elements (size):");
scanf("%d",&n);
printf("\n Enter the ELements to sort:");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
qsort(a,0,n-1);
printf("\n The ELements after sorting are:");
for(i=0;i<n;i++)
{
printf("%d\t",a[i]);
}
getch();
return 0;
}
Output:
Experiment No: 4
#include <stdio.h>
voidswap(int* a, int* b)
{
int temp = *a;
*a = *b;
*b = temp;
}
voidheapify(intarr[], int n, inti)
{
int left, right, largest;
largest = i;
left = 2 * i + 1;
right = 2 * i + 2;
// Check if left child exists and is larger than its parent
if (left < n &&arr[left] >arr[largest])
largest = left;
// Check if right child exists and larger than its parent
if (right < n &&arr[right] >arr[largest])
largest = right;
// if root is not the largest
if (largest != i) {
swap(&arr[i], &arr[largest]); //make root the largest
heapify(arr, n, largest); // Apply heapify to the largest node
}
}
voidheap_sort(intarr[], int n)
{
inti;
for (i = (n / 2) - 1; i>= 0; i--)
heapify(arr, n, i);
for (i = n - 1; i>= 0; i--) {
swap(&arr[0], &arr[i]); //Move the largest element at root to the end
heapify(arr, i, 0); //Apply heapify to reduced heap
}
}
intmain()
{
intarr[] = { 20, 13, 34, 56, 12, 10 };
int n = sizeof(arr) / sizeof(arr[0]);
printf("Array:\n");
for (inti = 0; i< n; i++)
printf("%d ", arr[i]);
heap_sort(arr, n);
return0;
}
Output:
Experiment No: 5
#include<stdio.h>
#include<stdlib.h>
#define SIZE 40
structqueue {
intitems[SIZE];
int front;
int rear;
};
struct queue* createQueue();
voidenqueue(struct queue* q, int);
intdequeue(struct queue* q);
voiddisplay(struct queue* q);
intisEmpty(struct queue* q);
voidprintQueue(struct queue* q);
structnode {
int vertex;
structnode* next;
};
struct node* createNode(int);
structGraph {
intnumVertices;
structnode** adjLists;
int* visited;
};
// BFS algorithm
voidbfs(struct Graph* graph, intstartVertex){
structqueue* q = createQueue();
graph->visited[startVertex] = 1;
enqueue(q, startVertex);
while(!isEmpty(q)) {
printQueue(q);
intcurrentVertex = dequeue(q);
printf("Visited %d\n", currentVertex);
structnode* temp = graph->adjLists[currentVertex];
while (temp) {
intadjVertex = temp->vertex;
if (graph->visited[adjVertex] == 0) {
graph->visited[adjVertex] = 1;
enqueue(q, adjVertex);
}
temp = temp->next;
}
}
}
// Creating a node
struct node* createNode(int v){
structnode* newNode = malloc(sizeof(structnode));
newNode->vertex = v;
newNode->next = NULL;
returnnewNode;
}
// Creating a graph
struct Graph* createGraph(int vertices){
structGraph* graph = malloc(sizeof(structGraph));
graph->numVertices = vertices;
inti;
for (i = 0; i< vertices; i++) {
graph->adjLists[i] = NULL;
graph->visited[i] = 0;
}
return graph;
}
// Add edge
voidaddEdge(struct Graph* graph, intsrc, intdest){
// Add edge from src to dest
structnode* newNode = createNode(dest);
newNode->next = graph->adjLists[src];
graph->adjLists[src] = newNode;
// Create a queue
struct queue* createQueue(){
structqueue* q = malloc(sizeof(structqueue));
q->front = -1;
q->rear = -1;
return q;
}
if (isEmpty(q)) {
printf("Queue is empty");
} else {
printf("\nQueue contains \n");
for (i = q->front; i< q->rear + 1; i++) {
printf("%d ", q->items[i]);
}
}
}
intmain(){
structGraph* graph = createGraph(6);
addEdge(graph, 0, 1);
addEdge(graph, 0, 2);
addEdge(graph, 1, 2);
addEdge(graph, 1, 4);
addEdge(graph, 1, 3);
addEdge(graph, 2, 4);
addEdge(graph, 3, 4);
bfs(graph, 0);
return0;
}
Experiment No: 6
void DFS(int);
int G[10][10],visited[10],n; //n is no of vertices and graph is sorted in array G[10][10]
void main()
{
int i,j;
printf("Enter number of vertices:");
scanf("%d",&n);
//read the adjecency matrix
printf("\nEnteradjecency matrix of the graph:");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&G[i][j]);
//visited is initialized to zero
for(i=0;i<n;i++)
visited[i]=0;
DFS(0);
}
void DFS(int i)
{
int j;
printf("\n%d",i);
visited[i]=1;
for(j=0;j<n;j++)
if(!visited[j]&&G[i][j]==1)
DFS(j);
}
Experiment No: 7
Aim: Write a Program to find Minimum Spanning Tree using 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);
void main()
{
printf("Kruskal's algorithm in C\n");
printf("========================\n");
u = find(u);
v = find(v);
if (uni(u, v))
{
printf("%d edge (%d,%d) =%d\n", ne++, a, b, min);
mincost += min;
}
int find(int i)
{
while (parent[i])
i = parent[i];
return i;
}
return 0;
}
Experiment No: 8
Aim: Write a Program to find Minimum Spanning Tree using Prim's algorithm
#include<stdio.h>
#include<stdlib.h>
int G[MAX][MAX],spanning[MAX][MAX],n;
int prims();
int main()
{
int i,j,total_cost;
printf("Enter no. of vertices:");
scanf("%d",&n);
printf("\nEnter the adjacency matrix:\n");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&G[i][j]);
total_cost=prims();
printf("\nspanning tree matrix:\n");
for(i=0;i<n;i++)
{
printf("\n");
for(j=0;j<n;j++)
printf("%d\t",spanning[i][j]);
}
printf("\n\nTotal cost of spanning tree=%d",total_cost);
return 0;
}
int prims()
{
int cost[MAX][MAX];
int u,v,min_distance,distance[MAX],from[MAX];
int visited[MAX],no_of_edges,i,min_cost,j;
//create cost[][] matrix,spanning[][]
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
if(G[i][j]==0)
cost[i][j]=infinity;
else
cost[i][j]=G[i][j];
spanning[i][j]=0;
}
//initialise visited[],distance[] and from[]
distance[0]=0;
visited[0]=1;
for(i=1;i<n;i++)
{
distance[i]=cost[0][i];
from[i]=0;
visited[i]=0;
}
min_cost=0; //cost of spanning tree
no_of_edges=n-1; //no. of edges to be added
while(no_of_edges>0)
{
//find the vertex at minimum distance from the tree
min_distance=infinity;
for(i=1;i<n;i++)
if(visited[i]==0&&distance[i]<min_distance)
{
v=i;
min_distance=distance[i];
}
u=from[v];
//insert the edge in spanning tree
spanning[u][v]=distance[v];
spanning[v][u]=distance[v];
no_of_edges--;
visited[v]=1;
//updated the distance[] array
for(i=1;i<n;i++)
if(visited[i]==0&&cost[i][v]<distance[i])
{
distance[i]=cost[i][v];
from[i]=v;
}
min_cost=min_cost+cost[u][v];
}
return(min_cost);
}
Experiment No: 9
int graph[N][N] = {
{0, 10, 15, 20},
{10, 0, 35, 25},
{15, 35, 0, 30},
{20, 25, 30, 0}
};
int minKey(int key[], bool mstSet[]) {
int min = INT_MAX, min_index;
for (int v = 0; v < N; v++) {
if (mstSet[v] == false && key[v] < min) {
min = key[v];
min_index = v;
}
}
return min_index;
}
int primMST(int graph[N][N]) {
int parent[N];
int key[N];
bool mstSet[N];
for (int i = 0; i< N; i++) {
key[i] = INT_MAX;
mstSet[i] = false;
}
key[0] = 0;
parent[0] = -1;
for (int count = 0; count < N - 1; count++) {
int u = minKey(key, mstSet);
mstSet[u] = true;
int mstWeight = 0;
for (int i = 1; i< N; i++) {
mstWeight += graph[i][parent[i]];
}
return mstWeight;
}
int firstMin(int i, int graph[N][N]) {
int min = INT_MAX;
for (int k = 0; k < N; k++)
if (i != k && graph[i][k] < min)
min = graph[i][k];
return min;
}
int secondMin(int i, int graph[N][N]) {
int first = INT_MAX, second = INT_MAX;
for (int j = 0; j < N; j++) {
if (i != j) {
if (graph[i][j] <= first) {
second = first;
first = graph[i][j];
} else if (graph[i][j] <= second && graph[i][j] != first) {
second = graph[i][j];
}
}
}
return second;
}
void TSPRec(int curr_bound, int curr_weight, int level, int parent[], bool visited[N], int
graph[N][N]) {
if (level == N - 1) {
if (graph[parent[level - 1]][level] != 0) {
int current_pathweight = curr_weight + graph[parent[level - 1]][level];
if (current_pathweight<curr_bound) {
printf("Path: ");
for (int i = 0; i< N; i++) {
printf("%d ", parent[i]);
}
printf("%d\n", level);
printf("Cost: %d\n", current_pathweight);
printf("-------------\n");
}
}
return;
}
for (int i = 0; i< N; i++) {
if (!visited[i] && graph[parent[level - 1]][i] != 0) {
int temp = curr_bound;
curr_weight += graph[parent[level - 1]][i];
if (level == 1)
curr_bound -= (firstMin(parent[level - 1], graph) + firstMin(i, graph)) / 2;
else
curr_bound -= (secondMin(parent[level - 1], graph) + firstMin(i, graph)) / 2;
return 0;
}
Output
Path: 0 1 2 3
Cost: 80
-------------
Path: 0 2 1 3
Cost: 80