Post on 02-Jun-2018
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.
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
3/56
3
}
else {
dy = 1;
dx = dy / m;
}
x1 = x1 + dx;
y1 = y1 + dy;
putpixel(x1, y1, RED);
delay(20);
}
}
Output:-
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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:-
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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/10/2019 MCA 3rd sem ADA
8/56
8
Output:-
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
11/56
11
printf("\nSorted list is\n");
for(i=0;i
8/10/2019 MCA 3rd sem ADA
12/56
12
}}
while(h
8/10/2019 MCA 3rd sem ADA
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)
8/10/2019 MCA 3rd sem ADA
14/56
14
pivot_place=true;
if(arr[piv]
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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 ;
8/10/2019 MCA 3rd sem ADA
17/56
17
}
}
t = a[lower] ;
a[lower] = a[q] ;
a[q] = t ;
return q ;
}
Output:-
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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-- )
8/10/2019 MCA 3rd sem ADA
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 ;
}
}
8/10/2019 MCA 3rd sem ADA
22/56
22
Output:-
8/10/2019 MCA 3rd sem ADA
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++)
8/10/2019 MCA 3rd sem ADA
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)
{
8/10/2019 MCA 3rd sem ADA
25/56
25
large = arr[i];
}
while(large > 0)
{
num++;
large = large/10;
}
for(passes=0 ; passes
8/10/2019 MCA 3rd sem ADA
26/56
26
}
}
div*=10;
}
}
}
Output:-
8/10/2019 MCA 3rd sem ADA
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++)
8/10/2019 MCA 3rd sem ADA
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++ )
8/10/2019 MCA 3rd sem ADA
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:-
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
32/56
32
k = A[i];
}
}
Counting_sort(A, k, n);
getch();
}
Output:-
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
34/56
34
getch();
}
Output:-
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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:-
8/10/2019 MCA 3rd sem ADA
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.
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
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)
8/10/2019 MCA 3rd sem ADA
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 */
8/10/2019 MCA 3rd sem ADA
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()
{
8/10/2019 MCA 3rd sem ADA
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 = createNode(1);
vertex[1] = newnode;
newnode->next = createNode(4);
newnode->next->next = createNode(6);
newnode = createNode(1);
vertex[2] = newnode;
newnode->next = createNode(5);
newnode->next->next = createNode(6);
newnode = createNode(2);
vertex[3] = newnode;
newnode->next = createNode(6);
newnode = createNode(3);
vertex[4] = newnode;
newnode->next = createNode(6);
newnode = createNode(2);
vertex[5] = newnode;
newnode->next = createNode(3);
8/10/2019 MCA 3rd sem ADA
44/56
44
newnode->next->next = createNode(4);
newnode->next->next->next = createNode(5);
/* depth first search operation */
depthFirstSearch(1, vertex);
while (index < VERTEXCOUNT)
{
deleteNodes(vertex[index]);
index++;
}
getch();
}
Output:-
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
46/56
46
if(cost[i][j]
8/10/2019 MCA 3rd sem ADA
47/56
47
Output:-
8/10/2019 MCA 3rd sem ADA
48/56
8/10/2019 MCA 3rd sem ADA
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
8/10/2019 MCA 3rd sem ADA
50/56
50
{
if(w[i]>4)
break;
else
x[i]=1.0;
u=u-w[i];
}
if(i
8/10/2019 MCA 3rd sem ADA
51/56
51
Output:-
8/10/2019 MCA 3rd sem ADA
52/56
8/10/2019 MCA 3rd sem ADA
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 (i = 0; i < vertexCount; i++)
{
for (j = 0; j < vertexCount; j++)
{
printf("Edge weight %d to %d(0 if no edge):", i + 1, j + 1);
8/10/2019 MCA 3rd sem ADA
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");
for (i = 0; i < vertexCount; i++)
{
for (j = 0; j < vertexCount; j++)
{
printf("%3d", edgeLength[i][j]);
}
printf("\n");
}
/* Calculate shortest path from each vertex to every other vertices */
for (i = 0; i < vertexCount; i++)
{
for (j = 0; j < vertexCount; j++)
8/10/2019 MCA 3rd sem ADA
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");
for (i = 0; i < vertexCount; i++)
{
for (j = 0; j < vertexCount; j++)
{
if (res[i][j] == INFINITY)
printf("%3d", 0);
else
printf("%3d", res[i][j]);
}
printf("\n");
}
getch();
}
8/10/2019 MCA 3rd sem ADA
56/56
Output:-