lab manual MCSE 101.docx

7/27/2019 lab manual MCSE 101.docx

http://slidepdf.com/reader/full/lab-manual-mcse-101docx 1/35

LAB MANUAL

DESIGN AND ANALYSIS OF ALGORITHMS

SCHOOL OF COMPUTER SCIENCE & ENGINEERING

BAHRA UNIVERSITY SHIMLA HILLS



Page | 1



Page | 2

Table of contents

1.Wap in c to implement binary search algorithm. ............................................................................................ 3

2.Wap in c to implement linear search algorithm. ............................................................................................. 4

3.Wap in c to implement quick sort algorithm. .................................................................................................. 5

4.Wap in c to implement selection sort algorithm. ............................................................................................ 7

5. Wap in c to implement merge sort algorithm................................................................................................. 8

6. Wap in c to implement knapsack problem. .................................................................................................. 10

7. Wap in c to implement travelling salesman problem. .................................................................................. 14

8. Wap in c to implement graph coloring. ......................................................................................................... 16

9. Wap in c to implement prim’s algorithm. .................................................................................................... 18

10. Wap in c to implement kruskal’s algorithm................................................................................................ 22

11. Wap in to implement dijakstra algorithm. .................................................................................................. 25

12. Wap in c to implement 15 – puzzle problem............................................................................................... 28



Page | 3

1. wap in c to implement binary search algorithm.

#include <stdio.h>

int main ()

{

int c, first, last, middle, n, search, array [100];

printf (“enter number of elements\n”);

scanf (“%d”, &n);

printf (“enter %d integers\n”, n);

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

scanf (“%d”, array*c+);

printf (“enter value to find \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 found at location %d \n”, search, middle1);

break;

) else

last = middle-1;

middle= (first+last)/2;

}

if (first>last)



Page | 4

printf (“not found! %d is not present in the list.\n”, search);

return0; }

2. wap in c to implement linear search algorithm.

#include <stdio.>

int main ()

{

int array [100], search, c, number;

printf (“enter the number of element in array\n”);

scanf (“%d”, &number);

printf (“enter %numbers\n”, number);

for (c= 0; < number; c++)

scanf (“%d”, &array*c+);

printf (“enter the number to search \n”);

scanf (“%d”, &search);

for (c=0; c< number; c++)

{

if (array[c] ==search) /*if required element found */

{

printf (“%d is present at location %d.\n”, search, c1);

break;

}

}

if (c==number)

printf (“%d is not present in array .\n”, search);

return0;

}



Page | 5

3. wap in c to implement quick sort algorithm.

#include<stdio.h>

int split (int*, int, int);

void main (){

int arr[10]={11,2,9,13,57,25,17,1,90,3};

int i;

void quicksort (int*, int, int)

quicksort (arr, 0, 9);

printf (“\narray after sorting; \n”);

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

printf 9”%d\t”, arr*i+); }

void quicksort (int a [], int lower, int upper)

{

int i;

if (upper>lower)

{

i =split (a, lower, upper);

quicksort (a, lower, i-1);

quicksort (a, i+1, upper);

}

}

int split (int a [], int lower, int upper)

{

int i, p, q, t;

p= lower+1;

q=upper;

i=a [lower];



Page | 6

while (q>=p)

{

while (a[p] <i)

p++;

while (a[q]>i)

q--;

if (p>q){

t=a[p];

a[q] =a[q];

a[q] =t;

}

}

t=a [lower];

a [lower] =a[q];

a[q] =t;return;

}



Page | 7

4 wap in c to implement selection sort algorithm.

#include <stdio.h>

int main ()

{

int array [100], n, c, d, position, swap;

printf (“enter number of element\n”);

scanf (“%d’, &n);

printf (“enter %d integers\n”, n);

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

scanf (%d”, &array*c+);

for (c=0; c< (n-1); c++)

{

position =c;

for (d=c+1; d<n; d++)

{

if (array [position]> array[d])

position=d;

}

if position1=c)

{

swap=array[c];

array[c] =array [position];

array [position] =swap;

} }

printf (“sorted list in ascending order: \n”);

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

printf (“%d\n”, array*c+);

return (0);}



Page | 8

5. wap in c to implement merge sort algorithm.

#include<stdio.h>

#include<coino.h>

void main (void)

{

int array [100], n, i=0

clrscr ();

printf (“enter the element to be sorted :”);


printf (“\nenter the elements to be sorted: \n”);

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

{

printf (“\t array *%d+ =”, i);

scanf (‘%d’, &array*i+);

}

printf (“\n before mergesort ;”); // array before mergesort

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

{

printf (“%4d’, array *i+);

}

printf (“\n”);

mergesort (array, 0, n-1);

printf (“\n”);

mergsort (array, 0, n-1);

printf (“\n after mergsort :”); // array after mergsort

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

{

printf (%d4d’, array *i+);



Page | 9

}

printf (“\n”);

getch ();

}

void mergsort (int arr [], int i, int h)

{

int i=0

int length = h-1+1;

int pivot =0;

int merge 1= 0;

int merge2 =0;

int temp [100];

if (i==h)

return;

pivot = (i+h)/2;

mergesort (arr, i, pivot);

mergesort (arr, pivot +1, h);

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

temp [1] = arr [1+i];

}

merg1 =0;

merg2=pivot-1+1;

for (i=0; i< length; i++

{

if (merge2<=h-1)

{

if (merg1<=pivot-1)

{



Page | 10

if (temp [merge1]>temp [merge2])

{

arr [i+1] =temp [merge2++1];

}

else

{

arr [i+1] = temp [merge1++];

}

}

else

{

arr [i+1] =temp [merge2++];

}

}

else

{

arr [i+1] =temp [merge1++];

}}

}

6. wap in c to implement knapsack problem.



Page | 11

#include<stdio.h>

#include<conio.h>

int w[10],p[10],v[10],n,i,j,cap,x[10]={0};

int max (int, i, int j)

{

return ((i>j)? i: j);

}

int knap (int i, int j)

{

int value;

if (v[i] [j] <0)

{

if (j<w[i])

value=kanp (i-1, j);

else

value = max (kanp (i-1, j), p[i] +kanp (i-1, j-w[i]));

n[i] [j] =value;

}return (v[i] [j]);

}

void main ()

{

int profit, count =0;

clrscr ();

printf (“\enter the number of elements \n”);


printf (“\enter the profit and weights of the elements\n”);

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

{



Page | 12

printf (“for item no %d\n”, i);

scanf (“%d%d’, &p*i+, &w*i+);

}

printf (‘\nenter the capacity \n”);

scanf (“%d”, &cap);

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

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

if ((i==0) ‼ (j==0))

v[i] [j] =0;

else

v[i] [j] =-1;

profit=knap (n, cap);

i=n;

j=cap;

while (j1=0&&i1=0)

{

if (v[i] [j] 1=v [i-1] [j])

{x[i] =1;

j=j-w[i];

i-;

}



Page | 13

else

i--;

}

printf (“items included are \n”);

printf (“si.no\tweight\tprofit\n”);

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

if(x[i])

printf (“%d\t%d\t%d\n”, count, w*i+, p[i]);

printf (“total profit = %d\n”, profit);

getch ();

}



Page | 14

7. wap in c to implement travelling salesman problem.

/* about this algorithm:

*have we use dynamic programming to find a solution to the

* travelling salesperson problem. the problem consist of finding

* the least – cost cycle in a given set of modes*/#include <stdio.h>

#define max 100

# define infinity 999

int top_up (int c [] [max], int tour [], int start, int n);

int main ()

{

int n; /* number of cities*/

int i, j; /* loop counters */

int c [max] [max]; /* cost matrix. */int cost; / * least cost. */

printf (“this program demonstrates the tsp program.”);

printf (“\nhow many cities to traverse?”);


printf (“enter the cost matrix: (999: no connection)\n”);

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

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

scanf (“%d”, &c*i+ *j+);

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

tour [1] =i;

cost=tsp_dp(c, tour, 0, n);

printf (“minimum cost: %d\n tour;” cost);

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

printf (“%d”, tour*i+ 1);

printf (“1\n”);

}

int tsp_dp (int c [] [max], int tour [], int start, int n){

int i, j, k; /* loop counter. */

int temp [max]; /* temporary during calculations.*/ int minimal tour [max); /* minimal tour

array.*/

int mincost; /* minimal cost. */

int ccost; /* current cost. */



Page | 15

/* end of recursion condition. */

if (start == n-2)

return c (tour [n-2]] [tour [n-1]] +c [tour [n-1]] [0];

/* compute the tour starting from the current city. */

mincost= infinity;

for (i= start +1; i<n; i++)

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

temp[j] =tour[j];

/* adjust positions. */

temp [start +1] = tour [i];

temp[i] = tour [start +1];

/* found a better cycle? (recurrence derivable)*/

if (c [tour [start]] [tour[i] +

(ccost= tsp_dp (c, temp, start +1, n)) < mincost) {

mincost = c [tour [start]] [tour[i]] +ccost;

for (k=0; k<n; k++)mintour[k] = temp[k];

}

}

/* set the minimum –tour array.*/

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

tour [i] = mintour[i];

return mincost;

}



Page | 16

8. wap in c to implement graph coloring.

# include<stdio.h>

int g [50] [50].x [50]; // g: adjacency matrix, x: color

void next_color (int k) {

int i, j;x [k] =1 // coloring vertex color 1

for (i=0; i<k; i++) { // checking all k-1 vertices – backtracking

if (g[i] [k] 1=0&&x[k] ==x[i]) // if connected and has same color

x [k] = x [i] +1; // assign higher color than x [i]

}

}

int main () {

int n, e, i j, k, l;

printf (“enter no, of vertices :”);

scanf (%d”, &n); // total vertices

printf (“enter no. of edges :”);

scanf (“%d”, &e); // total edges

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

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

g[i] [j] =0; // assign 0 to all index of adjacency matrix

printf (“enter index where value is i-->\n”);

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

{

scanf (“%d %d “, &k, &l);

g[k] [i] =1;

g[i] [k] =1;

}

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



Page | 17

next_color (i); // coloring each vertex

printf (“color of vertices-->\n”);

for (i=0 ;< n; i++) // displaying color of each vertex

printf (“vertex *%d\n”, i1, x*i+);

return0;

}



Page | 18

9. wap in c to implement prim’s algorithm.

#include<stdio.h>

#include<conio.h>

int n, cost [10] [10];

void prim ()

{

int i, j, k, l, x, nr [10], temp, min_cost=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];

k=i;

i=j;

}

}

/* now we have first smallest edge in graph */

tree [0] [0] =k;

tree [0] [1] =i

tree [0] [2] temp;

min_cost= temp;

/*now we have to find min dis of each

vertex from either k or i

by initializing nr [] array



Page | 19

*/

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

{

if (cost [i] [k] < cost [i] [i])

nr[i] =k;

else

nr[i] =i;

}

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

nr[k] =100;

nr [i] =100;

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

temp=99;

for (i=1; i<n-1; i++)

{

if (nr[j] 1=100&& cost [j] [nr[j]] < temp)

{

temp=cost[j] [nr[j]];x=j;

}

}

/* now i have got next vertex */

tree [i] [0] =x;

tree [i] [1] = nr [x];

tree[i] [2] =cost [x] [nr[x]];

min_cost=min_cost +cost[x] [nr[x]];

nr[x] =100;

/*now find if x is nearest to any vertex

than its previous near value*/



Page | 20

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

{

if (nr[j] 1=100 && cost [j] nr[j]]> cost [j] [x])

nr [j] =x;

}

temp=99;

}

/* now i have the answer, just going to print it */

printf (“n the main spanning tree is :-“);

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

{

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

printf (“%d”, tree *i+ *j+);

printf (“n”);

}

printf (“n min cost: - %d “, mon_cost);

}

///////////////////////////////////////////////////////{

void main ()

{

int i, j;

clrscr ();

printf (“n enter the no. of vertices :-“)




Page | 21

printf (“enter the costs of edges in matrix form :-“);

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

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

scanf (“%d”, /& cost *i+ *j+);

printf (“n the matrix is: - “);

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

{

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

printf (“%dt’, cost *i+ *j+);

printf (“n”);

}

prim ();

getch ();

}



Page | 22

10. Wap in c to implement 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 ()

{

clrscr ();

printf (“\n\n\t implementation of kruskal’s algorithm\n\n”);

printf (“\nenter the no. of vertices\n”);


printf (“\nenter the cost adjacency matrix \n”);

for (i=1; i<=n; j++)

{

scanf (“%d”, &cost *i+ *j+);

if (cost [i] [j] ==0

cost[i] [] =999;

}

}

printf (“\n the edge of minimum cost spanning tree are \n\n”);

while (ne<n)

{

for (i=1, min=999: i<=n; i++)

{

for (j=1; j<=n; j++)



Page | 23

{

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 (“\n%d edge (%d, %d) =%d\n”, ne, a, b, min);

mincost+= min;

}

cost[a] [b] =cost[b] [a] =999;

}printf (“\n\minimum cost = %d\n”, mincost);

getch ();

}

int find (int i)

{

while (parent[i])

i=parent[i];

return i;

}



Page | 24

int uni (int, i, int, j)

{

if (i1=j)

{

parent [j] =i;

return1;

}

return0;

}



Page | 25

11. Wap in to implement dijakstra algorithm.

/ program to find shortested path using dijkstra’s algorithm this is a static implemention of

program using a two demientional weight matrix , but this

program can not support a searrio where number of nodes of a graph may change during execution

*/

#include<stdio.h>

#include<conio.h>

#define infinity 2000

#define maxnodes 4

#define member 1

#define nonmember 0

void shortpath (int weight [] (maxnodes}, int, int, int *, int precede []) ;

int main (void)

{

int i, j, s, t;

int weight [maxnodes] [maxnodes], precede [maxnodes], pd;

printf (“\nenter weight matrix “);

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

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

scanf (“%d “, & weight *i+ *j+);

for (i0; i< maxnodes; i++)

{

printf (“\n”);

printf (“%d”, weight *i+ *j+);

}

printf (“\n enter the starting node and the ending node :”);

scanf(“%d’, %s, &t);

shortpath (weight, s, t, & pd, precede);



Page | 26

printf (“\n the shortest path from node %d to %d is; %d ‘, s, t, pd);

return (0);

}

void shortest path (int weight [] maxnodes], int s, int t, int * pd, int precede [])

{

int distance [maxnodes], perm [maxnodes];

int current, i, j, k, dc;

int smalldist, newdist;

/* initialization of perm and distance array */

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

{

perm[i] = nomember;

distance[i] =infinity ;}

}

perm[s] =member;

distance[s] =0;

current=s;

while (current 1=t){

smallest = i nfinity;

dc= distance [current];

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

if (perm[i] ==nonmember)

{

newdist= dc + weight [current] [i];

if (newdist< distance[i])

{

distance [1] =newdist;

precede[i] =current;



Page | 27

}

if (distance[i] < smalldist)

{

smalldist=distance[i];

k=i;

}

} */ end of for if */

current =k;

perm [current] =member;

} /* end while */

*pd = distance [t];

}

/* end of shortpath function*/



Page | 28

12. wap in c to implement 15 – puzzle problem.

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

int table [4] [4] = {{1,2,3,4},{5,6,7,8,},{9,10,11,12,},{13,14,15,0};

int count=0;

void displaytable (void);

void movenumber (void);

void moveright (void);

void mobeleft (void);

void moveup (void);

void movedown (void);

void ownsetup (void);

void randomizer (void);

int check for finish (void);

main (void)

{

int rory;

print (“hello, and welcome to hunter’s 15 – puzzle1\n”);

print (“to play a randomly generated puzzle press r\n”);

printf (“to set up your own puzzle press y\n”);

rory=getchar ();

if (rory==’r’)

randomizer ();

if (rory==’o’)

ownsetup ();



Page | 29

display table ();

// function used to randomize the grid

void randomize () {

stand (time (null));

char unsigned x = rand () %4;

if (x=0)

{

moveup ();

}

else if (x=1)

{

movedown();

}

else if (x=2)

{

moveleft ();

}

else if (x=3);{

moveright ();

}

}

// function used to set up your own grid

void ownsetup ();

{

printf (“\n please enter the number for the top row from left to right\n”);

printf (“followed by the number for the second row from left to right. etc. \n”);

printf (“please do not forget to press enter in between each number.\n”);

scanf (“%d”, &table *0+ *0+);



Page | 30

scanf (“%d”, &table *0+ *1+);

scanf (“%d”, &table *0+ *0+);

scanf (“%d”, &table *0+ *1+);

scanf (“%d”, &table *0+ *2+);

scanf (“%d”, &table *0+ *3+);

scanf (“%d”, &table *1+ *0+);

scanf (“%d”, &table *1+ *1+);

scanf (“%d”, &table [1] [2]);

scanf (“%d”, &table *1+ *3+);

scanf (“%d”, &table *2+ *0+);

scanf (“%d”, &table *2+ *1+);

scanf (“%d”, &table *2+ *2+);

scanf (“%d”, &table *2+ *3+);

scanf (“%d”, &table *3+ *0+);

scanf (“%d”, &table *3+ *1+);

scanf (“%d”, &table *3+ *2+);

scanf (“%d”, &table *3+ *3+);

}// function used to move the numbers in the grid

void move number () {

int key;

printf (“\n\enter a letter (i, j, k, or m) ;”);

key= getchar ();

if (key==’j’)

move left ();

if (key’k’)

move right ();

if (key==’i’)

move up ();



Page | 31

if (key==’m’)

movedown ();

displaytable();

}

// move the number to the right

void moveright();

int temp, i, j;

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

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

if (table[i] [j] ==0 &&j 1=0) {

temp=table[i] [j-1];

table[i] [j] =temp;

}

}

}

}

// move the number to the leftvoid moveleft () {

int temp ,i, j;

for (i=3 i>=0; i--) {

for (j=3; j>=0; j--) {

if (table {i] [j] ==0 &&j 1=3) {

temp=table[i] [j+1];

table[i] [j+1] =0;

table[i] [j] =temp;

}

}

}



Page | 32

}

// move the number up

void moveup() {

int temp, i, j;

for (i=3: i>=0; i--) {

for (j=3; j>=0; j--) {

if (table [i] [j] ==0 && i 1 = 3) {

temp = table [i+1] [j];

table [i+1] [j] =0;

table[i] [j] = temp;

}

}

}

}

// move the number down

void movedown () {

int temp, i, j;

for (i=0; i<4; i++) {for (j=0; j<4; j++) {

if (table[i] [j] ==0&&i1=0) {

temp=table[i-1] [j];

table[i] [j] =temp;

}

}

}

}

// function used to display the table

void display table {} {

int i, j;



Page | 33

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

printf (“\n\n”);

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

if (table [i] [j] ==0)

printf (“ “);

else if (table [i] [j] <10)

printf (‘%d”, table *i+ *j+);

else

printf(“%d’, table*i+ *j+);

}

}

printf(“\n’);

}

// function used to spot a winning board

int checkfor finish (void) {

int i, j, temp, result;

result=0;

temp=1;for (i=0; i<4; i++) {

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

if (table[i] [j] ==temp) {

temp+=1;

}

}

}

if (temp==15)

result=1;

return result;

}}



lab manual MCSE 101.docx

Documents