MCA 3rd sem ADA

8/10/2019 MCA 3rd sem ADA

1/56

1

1. Program to draw a line using DDA line algorithm.

2.

Program for implementing Bresenhams algorithm for linegeneration.

3. Algorithm & program of insertion sort.

4.

Algorithm & program of merge sort.

5.

Algorithm & program of quick sort.

6.

Algorithm & program of heap sort.

7.

Algorithm & program of radix sort.

8. Algorithm & program of bucket sort.

9.

Algorithm & program of counting sort.

10. Algorithm & program of linear search.

11. Algorithm & program of binary search.

12. Algorithm & program of BFS.

13. Algorithm & program of DFS.

14.

Algorithm & program to find minimum spanning tree using

prims algorithm.

15.

Algorithm & program to find optimal solution for a knapsackproblem using greedy method.

16. Algorithm & program to implement Dijkstras algorithm.


2/56

2

/* Program of DDA line drawing. */

#include

#include

#include

#include

void lineDDA(int, int, int, int);

void main() {

int x1, y1, xn, yn;

int gd = DETECT, gm;

initgraph(&gd, &gm, "");

printf("Enter the starting coordinates of line: ");

scanf("%d %d", &x1, &y1);

printf("Enter the ending coordinates of line: ");

scanf("%d %d", &xn, &yn);

lineDDA(x1, y1, xn, yn);

getch();

}

void lineDDA(int x1, int y1, int xn, int yn) {

int dx, dy, m, i;

m = (yn-y1)/(xn-x1);

for (i=x1; i


3/56

3

}

else {

dy = 1;

dx = dy / m;

}

x1 = x1 + dx;

y1 = y1 + dy;

putpixel(x1, y1, RED);

delay(20);

}

}

Output:-


4/56

4

/* Program of Bresanhem line drawing . */

# include

# include

# include

void main()

{

int dx,dy,x,y,p,x1,y1,x2,y2;

int gd,gm;

clrscr();

printf("\n\n\tEnter the co-ordinates of first point : ");

scanf("%d %d",&x1,&y1);

printf("\n\n\tEnter the co-ordinates of second point : ");

scanf("%d %d",&x2,&y2);

dx = (x2 - x1);

dy = (y2 - y1);

p = 2 * (dy) - (dx);

x = x1;

y = y1;

detectgraph(&gd,&gm);

initgraph(&gd,&gm,"c:\\tc\\bgi");

putpixel(x,y,WHITE);

while(x


5/56

5

y=y;

p = p + 2 * (dy);

}

else {

x=x+1;

y=y+1;

p = p + 2 * (dy - dx);

}

putpixel(x,y,WHITE);

}

getch();

closegraph();

}

Output:-


6/56

6

/* Program and algorithm of insertion sort. */

Algo:

Input :- An array A[0:n-1] of n element.

Output :- An array A[0:n-1] of n element in acceding order.

For(i=1 to n-1) do

{

v =A[i];

j =(i-1);

while (j>=0) and (A[j]>v) do

{

A[j+1]=A[j];

J=j-1;

A[j]=v;

}

}

Program:

#include

#include

void main( )

{

int arr[5] = { 25, 18, 32, 14, 3 } ;

int i, j, k, temp ;

clrscr();

printf ( "\t\t\t\t Insertion Sort\n\n" ) ;

printf ( "Array before sorting:\n") ;

for ( i = 0 ; i


7/56

7

for ( i = 1 ; i arr[i] )

{

temp = arr[j] ;

arr[j] = arr[i] ;

for ( k = i ; k > j ; k-- )

arr[k] = arr[k - 1] ;

arr[k + 1] = temp ;

}

}

}

printf ( "\n\n" ) ;

printf ( "Array after sorting:\n") ;

for ( i = 0 ; i


8/56

8

Output:-


9/56

9

/* Program and algorithm of merge sort. */

Algo:

Heap(item[],N)

{

Build_heap(item,N);

Heapify(item,N)

}

Build_heap(item[],N)

{

for(i=1;i


10/56

10

}

}

}

Program:

#include

#include

#define max 100

void mergesort(int low,int high);

void merge(int low,int mid,int high);

int a[max],n;

void main()

{

int i,k;

clrscr();

printf("\t\t\t\t Merge Sort\n\n");

printf("Enter the no of element\n");

scanf("%d",&n);

printf("\nEnter the %d value\n",n);

for(k=0;k


11/56

11

printf("\nSorted list is\n");

for(i=0;i


12/56

12

}}

while(h


13/56

13

/* Program and algorithm of quick sort. */

Algo:

Quick(int arr[],int low,int up)

{

int piv,temp,left,right;

left=low;

right=up;

piv=low; /*take first element of sublist as pivot */

if(low>=up)

/*loop till pivot is placed ar its proper place */

{

/* compare from right to left */

while(arr[piv]arr[right]])

{

temp=arr[piv];

piv=right;

}

/* Compare from left to rigth */

while(arr[piv]>=arr[left] && left!=piv)

left=left+1;

if(piv==left)


14/56

14

pivot_place=true;

if(arr[piv]


15/56

15

Program:

#include

#include

void quicksort ( int *, int, int ) ;

int split ( int *, int, int ) ;

void main( )

{

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

int i ;

clrscr();

printf ( "\t\t\t\t Quick Sort\n\n" ) ;

printf ( "Array before sorting:\n") ;

for ( i = 0 ; i


16/56

16

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] ;

while ( q >= p )

{

while ( a[p] < i )

p++ ;

while ( a[q] > i )

q-- ;

if ( q > p )

{

t = a[p] ;

a[p] = a[q] ;

a[q] = t ;


17/56

17

}

}

t = a[lower] ;

a[lower] = a[q] ;

a[q] = t ;

return q ;

}

Output:-


18/56

18

/* Program and algorithm of Heap sort. */

Algo:

Heap(item[],N)

{

Build_heap(item,N);

Heapify(item,N)

}

Build_heap(item[],N)

{

for(i=1;i


19/56

19

}

}

Program:

#include

#include

void makeheap ( int [ ], int ) ;

void heapsort ( int [ ], int ) ;

void main( )

{

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

int i ;

clrscr();

printf ( "\t\t\t\t Heap Sort\n\n" ) ;

makeheap ( arr, 10 ) ;

printf ( "Before Sorting:\n" ) ;

for ( i = 0 ; i


20/56

20

}

/* creates heap from the tree*/

void makeheap ( int x[ ], int n )

{

int i, val, s, f ;

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

{

val = x[i] ;

s = i ;

f = ( s - 1 ) / 2 ;

while ( s > 0 && x[f] < val )

{

x[s] = x[f] ;

s = f ;

f = ( s - 1 ) / 2 ;

}

x[s] = val ;

}

}

/* sorts heap */

void heapsort ( int x[ ], int n )

{

int i, s, f, ivalue ;

for ( i = n - 1 ; i > 0 ; i-- )


21/56

21

{

ivalue = x[i] ;

x[i] = x[0] ;

f = 0 ;

if ( i == 1 )

s = -1 ;

else

s = 1 ;

if ( i > 2 && x[2] > x[1] )

s = 2 ;

while ( s >= 0 && ivalue < x[s] )

{

x[f] = x[s] ;

f = s ;

s = 2 * f + 1 ;

if ( s + 1 i - 1 )

s = -1 ;

}

x[f] = ivalue ;

}

}


22/56

22

Output:-


23/56

23

/* Program and algorithm of radix sort. */

Algo:

Radix(A,d)

for i1 to d

use a sutable sort to sort array on digit i.

Program:

#include

#include

radix_sort(int array[], int n);

void main()

{

int array[100],n,i;

clrscr();

printf("Enter the number of elements to be sorted: ");

scanf("%d",&n);

printf("\nEnter the elements to be sorted: \n");

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

{

printf("\tArray[%d] = ",i);

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

}

printf("\nArray Before Radix Sort:"); //Array Before Radix Sort

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


24/56

24

{

printf("%8d", array[i]);

}

printf("\n");

radix_sort(array,n);

printf("\nArray After Radix Sort: "); //Array After Radix Sort

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

{

printf("%8d", array[i]);

}

printf("\n");

getch();

}

radix_sort(int arr[], int n)

{

int bucket[10][5],buck[10],b[10];

int i,j,k,l,num,div,large,passes;

div=1;

num=0;

large=arr[0];

for(i=0 ; i large)

{


25/56

25

large = arr[i];

}

while(large > 0)

{

num++;

large = large/10;

}

for(passes=0 ; passes


26/56

26

}

}

div*=10;

}

}

}

Output:-


27/56

27

/* Program and algorithm of bucket sort. */

Algo:

Bucket_sort[A]

nlength (A)

for i=1 to n do

insert A[i] into list B[n[i]]

for i=1 to n-1 do

sort list B with insertion sort

Concatenate the list B[0], B[1] _ _ _ B[n-1] together in order.

Program:

#include

#include

void Bucket_Sort(int array[], int n)

{

int i,j;

int count[15];

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

{

count[i] = 0;

}

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


28/56

28

{

(count[array[i]])++;

}

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

{

for(; count[i]>0;(count[i])--)

{

array[j++] = i;

}

}

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

{ printf("%d ", array[i]);

}

printf("\n");

}

void main()

{ int array[100];

int num;

int i;

clrscr();

printf("Enter How many Numbers : ");

scanf("%d",&num);

printf("\nEnter the %d elements to be sorted:\n",num);

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


29/56

29

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

}

printf("\nThe array of elements before sorting : \n");

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

{ printf("%d ", array[i]);

}

printf("\n\nThe array of elements after sorting : \n");

Bucket_Sort(array, num);

getch();

}

Output:-


30/56

30

/* Program and algorithm of count sort. */

Algo:

Counting_sort(A,B,K)

for i0 to k

do c[i]0

for j1 to length[A];

do c[A[j]]c[A[i]]+1

for j1 to k

do c[i]c[i]+c[i-1]

for jlength[A] down to 1

do B[c[A[j]]A[j]

c[A[j]]c[A[j]]-1

Program:

#include

#include

int Counting_sort(int A[], int k, int n)

{

int i, j;

int B[15], C[100];

for(i = 0; i


31/56

31

for(i = 1; i = 1; j--)

{ B[C[A[j]]] = A[j];

C[A[j]] = C[A[j]] - 1;

}

printf("\nThe Sorted array is :\n");

for(i = 1; i


32/56

32

k = A[i];

}

}

Counting_sort(A, k, n);

getch();

}

Output:-


33/56

33

/* Program of Linear Search. */

#include

#include

void main(){

int a[10],i,n,m,c=0;

clrscr();

printf("Enter the size of an array: ");

scanf("%d",&n);

printf("\nEnter the elements of the array: ");

for(i=0;i


34/56

34

getch();

}

Output:-


35/56

35

/* Program of Binary Search. */

#include

#include

void main()

{

int a[10],n=0,i,j,temp;

int beg,end,mid,target;

clrscr();

printf("Enter the total number=");

scanf("%d",&n);

printf("\nEnter the array elements=");

for(i=0;i


36/56

36

}

if(a[mid]==target)

{ printf("\n\nThe number is found at position %2d",mid+1);

}

else

{ printf("\n\nThe number is not found");

}

getch();

}

Output:-


37/56

37

/* Program and algorithm of BFS. */

Algo:

InputA graph G(V,E)

OutputSame graph G with vertices mark with consecutive integer

in order they are visited by BFS.

for every vertex in (V) marked it with 0 as a mark of being unvisited

count=0;

for each v in V do

if v is marked with 0

BFS(v);

BFS (v) count=count+1

Assign count to v and initialized queue with v while queue is not

empty do

for each vertex w in V which is adjacent to v do

if w is marked with 0

count=count+1

assign count to w and add w to the list and delete v from the

front of the list.


38/56

38

Program:

#include

#include

int a[20][20],q[20],visited[20],n,i,j,f=0,r=-1;

void bfs(int v)

{ for(i=1;i


39/56

39

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

printf("\n Enter the starting vertex:");

scanf("%d",&v);

bfs(v);

printf("\n The node which are reachable are:\n");

for(i=1;i


40/56

40

/* Program of and algorithm DFS. */

Algo:

InputA graph G(V,E)

OutputSame graph G with vertices mark with consecutive integer

in order they are visited by DFS.

for every vertex in (V) marked it with 0 as a mark of being unvisited

count=0;

for each v in V do

if v is marked with 0

DFS(v);

DFS(v)Recursive call for DFS for the vertex which is adjacent to v.

count =count+1

marked v with count

for each vertex w in V which is adjacent to v do

if w is marked with 0

DFS(w)


41/56

41

Program:

#include

#include

#include

#define VERTEXCOUNT 6

#define VISITED 1

struct node

{

int data;

struct node *next;

};

int visitVertex[VERTEXCOUNT];

struct node * createNode(int data)

{

struct node *newnode;

newnode = (struct node *)malloc(sizeof(struct node));

newnode->data = data;

newnode->next = NULL;

return newnode;

}

void depthFirstSearch(int index, struct node *vertex[])

{

struct node *temp;

/* mark the unvisted node as visited and print it to console */


42/56

42

visitVertex[index - 1] = VISITED;

temp = vertex[index - 1];

printf("VV(Visited Vertex): %d\n", index);

while (temp != NULL)

{

if (visitVertex[temp->data - 1] == VISITED)

temp = temp->next;

else

depthFirstSearch(temp->data, vertex);

}

}

void deleteNodes(struct node *myNode)

{

struct node *temp;

while (myNode != NULL)

{

temp = myNode;

myNode = myNode->next;

free(temp);

}

}

void main()

{


43/56

43

struct node *vertex[VERTEXCOUNT], *newnode;

int index = 0;

clrscr();

/* Create adjacency list for the graph */

newnode = createNode(2);

vertex[0] = newnode;

newnode->next = createNode(3);




newnode->next->next = createNode(6);















44/56

44


newnode->next->next->next = createNode(5);

/* depth first search operation */

depthFirstSearch(1, vertex);

while (index < VERTEXCOUNT)

{

deleteNodes(vertex[index]);

index++;

}

getch();

}

Output:-


45/56

45

/* Program of primsto find the minimum spanning tree. */

#include

#include

int a,b,u,v,n,i,j,ne=1;

int visited[10]={0},min,mincost=0,cost[10][10];

void main()

{

clrscr();

printf("\n Enter the number of nodes:");

scanf("%d",&n);

printf("\n Enter the adjacency matrix:\n");

for(i=1;i


46/56

46

if(cost[i][j]


47/56

47

Output:-


48/56


49/56

49

Program:

#include

#include

void main()

{

int n,m,i,u;

int p[20],w[20];

float x[20];

float optimal=0.0;

clrscr();

printf("Enter number of objects=");

scanf("%d",&n);

printf("\n\nEnter capacity of knapsack=");

scanf("%d",&m);

printf("\n\nEnter profit in decreasing order pi/wi=");

for(i=1;i


50/56

50

{

if(w[i]>4)

break;

else

x[i]=1.0;

u=u-w[i];

}

if(i


51/56

51

Output:-


52/56


53/56

53

Program:

#include

#include

#include

#define INFINITY 9999

void main()

{

int vertexCount, **edgeLength, **res;

int i, j, k;

clrscr();

printf("Enter the no of vertices:");

scanf("%d", &vertexCount);

edgeLength = (int **)calloc(sizeof(int), vertexCount);

res = (int **)calloc(sizeof(int), vertexCount);

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

{

edgeLength[i] = (int *)calloc(sizeof(int), vertexCount);

res[i] = (int *)calloc(sizeof(int), vertexCount);

}


{

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

{

printf("Edge weight %d to %d(0 if no edge):", i + 1, j + 1);


54/56

54

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

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

{

res[i][j] = INFINITY;

}

else

{

res[i][j] = edgeLength[i][j];

}

}

}

printf("Adjacent matrix for edge weights:\n");


{


{

printf("%3d", edgeLength[i][j]);

}

printf("\n");

}

/* Calculate shortest path from each vertex to every other vertices */


{



55/56

55

{

for (k = 0; k < vertexCount; k++)

{

if (res[j][k] > res[j][i] + res[i][k])

{

res[j][k] = res[j][i] + res[i][k];

}

}

}

}

printf("\nShortest path between vertices\n");


{


{

if (res[i][j] == INFINITY)

printf("%3d", 0);

else

printf("%3d", res[i][j]);

}

printf("\n");

}

getch();

}


56/56

Output:-

MCA 3rd sem ADA

Documents

Transcript of MCA 3rd sem ADA