IT-354 (15354)

GURU GOBIND SINGH

INDRAPRASTA UNIVERSITY

ALGORITHM ANALYSIS AND DESIGN FILE

SUBMITTED TO : SUBMITTED BY:

SONIKA DHAIYA Tenzin Chonyi

(ASSISTANT PROFESSOR) (06816403213)

B.tech CSE 6TH SEMESTER

INDEXS.No PROGRAM Signature

1 COUNTING SORT PROGRAM

2 MERGE SORT PROGRAM

3 RADIX SORT PROGRAM

4 KNAPSACK PROGRAM

5 LONGEST COMMON SUBSEQUENCE

6 Matrix Chain Multiplication Algorithm

7 Huffman Encoding program

8 Depth First Traversal (DFS)program

9 Breadth First Search (BFS) program

10 Dijkstra's shortest path algorithm

11 Prim's Minimum Spanning Tree (MST) algorithm

// 1.COUNTING SORT PROGRAM

#include<iostream.h>

#include<conio.h>

void main()

{

clrscr();

int a[100],b[100],c[100],i,n;

int k=0;

cout<<"\t\tEnter the total number of elements to be sorted:\n";

cin>>n;

cout<<"Enter the elements:\n";

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

{ cin>>a[i];

}

for(i=1; i<=n; i++) // can be included in the upper loop

{ if(k<a[i])

k=a[i];

}

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

{ c[i]=0;

}

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

{ c[a[i]]=c[a[i]]+1;

}

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

{ c[i]=c[i-1]+c[i];

}

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

{ b[c[a[i]]]=a[i];

c[a[i]]=c[a[i]]-1;

}

cout<<"\nThe sorted elements are as follow:\n";

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

{ cout<<b[i];

cout<<"\t"<<endl;

}

getch();

}

OUTPUT:

//2.MERGE SORT

#include<iostream.h>

#include<conio.h>

void merge(int *a, int low, int high, int mid)

{ int i, j, k, c[50];

i = low;

k = low;

j = mid + 1;

while (i <= mid && j <= high)

{ if (a[i] < a[j])

{ c[k] = a[i];

k++;

i++;

}

else

{ c[k] = a[j];

k++;

j++;

}

}

while (i <= mid)

{ c[k] = a[i];

k++;

i++;

}

while (j <= high)

{ c[k] = a[j];

k++;

j++;

}

for (i = low; i < k; i++)

{ a[i] = c[i];

}

}

void mergesort(int *a, 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,high,mid);

}

return;

}

void main()

{ int a[20], i, b[20],n;

cout<<"enter the number of element : ";

cin>>n;

cout<<"\nenter array elements : \n";

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

{ cin>>a[i];

}

mergesort(a, 0, n-1);

cout<<"\n\nsorted array : \n";

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

{ cout<<a[i]<<" ";

}

getch();

}

OUTPUT:

// 3.RADIX SORT PROGRAM

int getMax(int arr[], int n)

{

int max = arr[0];

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

if (arr[i] > max)

max = arr[i];

return max;

}

void countSort(int arr[], int n, int exp)

{

int output[100];

int i, count[10] = {0};

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

count[(arr[i] / exp) % 10]++;

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

count[i] += count[i - 1];

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

{

output[count[(arr[i] / exp) % 10] - 1] = arr[i];

count[(arr[i] / exp) % 10]--;

}

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

arr[i] = output[i];

}

void radixsort(int arr[], int n)

{

int m = getMax(arr, n);

for (int exp = 1; m / exp > 0; exp *= 10)

countSort(arr, n, exp);

}

int _tmain(int argc, _TCHAR* argv[])

{

int arr[100];

int n;

cout<<"enter the number of elements to be sorted : ";

cin>>n;

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

{

cin>>arr[i];

}

cout<<"\n\n Array element before Radix Sort : \n\t";

radixsort(arr, n);

cout<<"\n\n Array element after Radix Sort : \n\t";

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

cout << arr[i] << " ";

getch();

}

OUTPUT:

//4.KNAPSACK PROGRAM

#include<iostream.h>

#inlcude<conio.h>

void main()

{ int i;

float n,w[100],p[100],m;

float pw[100],x[100],temp,profit=0;

cout<<"enter the number of items : ";

cin>>n;

cout<<"enter the maximum weight which can be carried : ";

cin>>m;

cout<<"enter the price of all items : ";

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

{ cin>>p[i];

}

cout<<"\nenter the weight of all items :";

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

{ cin>>w[i];

pw[i]=p[i]/w[i];

}

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

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

{ if(pw[i]<pw[j])

{ temp=pw[i];

pw[i]=pw[j];

pw[j]=temp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

temp=w[i];

w[i]=w[j];

w[j]=temp;

}

}

}

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

{ if(m==0)

break;

else if(w[i]<m)

{ x[i]=1.0;

m=m-w[i];

}

else

{ x[i]=m/w[i];

m=0;

}

}

for(;i<n;i++)

x[i]=0;

cout<<"\n\n maximum profit is : ";

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

{ if(x[i]==0)

break;

profit+=p[i]*x[i];

cout<<p[i]<<"*"<<x[i]<<" ";

}

cout<<" = "<<profit;

getch();

}

OUTPUT:

//5.LONGEST COMMON SUBSEQUENCE

#include<iostream.h>

#include<conio.h>

char X[100],Y[100];

int c[100][100];

int m,n;

void LCS()

{

m = strlen(X);

n=strlen(Y);

int i,j;

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

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

c[i][j]=0;

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

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

{

if (X[i-1]==Y[j-1])

c[i][j]=c[i-1][j-1]+1;

else

c[i][j]=max(c[i][j-1],c[i-1][j]);

}

}

void printLCS(int i,int j)

{

if (i==0 || j==0)

return;

if (X[i-1]==Y[j-1])

{

printLCS(i-1,j-1);

cout<<X[i-1];

}

else if (c[i][j]==c[i-1][j])

printLCS(i-1,j);

else

printLCS(i,j-1);

}

int _tmain(int argc, _TCHAR* argv[])

{

cout<<"Enter 1st Sequence : ";

cin>>X;

cout<<"\nEnter 2nd Sequence : ";

cin>>Y;

LCS();

cout<<"\n\n longest common subsequence is :\n\t";

printLCS(m,n);

getch();

}

OUTPUT:

// 6. Matrix Chain Multiplication Algorithm

#include<stdio.h>

#include<limits.h>

int MatrixChainOrder(int p[], int n)

{ int m[n][n];

int i, j, k, L, q;

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

m[i][i] = 0;

for (L=2; L<n; L++)

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

{ j = i+L-1;

m[i][j] = INT_MAX;

for (k=i; k<=j-1; k++)

{ q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];

if (q < m[i][j])

m[i][j] = q;

}

}

}

return m[1][n-1];

}

int main()

{ int arr[10],size,i;

printf("enter number of matrices\n");

scanf("%d",&size);

printf("ënter orders of the matrix\n");

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

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

printf("Minimum number of multiplications is %d ",

MatrixChainOrder(arr, size));

getchar();

return 0;

}

OUTPUT:

//7. Huffman Encoding program

#include <stdio.h>

#include <stdlib.h>

#define MAX_TREE_HT 100

struct MinHeapNode

{ char data; // One of the input characters

unsigned freq; // Frequency of the character

struct MinHeapNode *left, *right; // Left and right child of this node

};

struct MinHeap

{ unsigned size; // Current size of min heap

unsigned capacity; // capacity of min heap

struct MinHeapNode **array; // Attay of minheap node pointers

};

struct MinHeapNode* newNode(char data, unsigned freq)

{ struct MinHeapNode* temp =

(struct MinHeapNode*) malloc(sizeof(struct MinHeapNode));

temp->left = temp->right = NULL;

temp->data = data;

temp->freq = freq;

return temp;

}

struct MinHeap* createMinHeap(unsigned capacity)

{ struct MinHeap* minHeap =

(struct MinHeap*) malloc(sizeof(struct MinHeap));

minHeap->size = 0; // current size is 0

minHeap->capacity = capacity;

minHeap->array =

(struct MinHeapNode**)malloc(minHeap->capacity * sizeof(struct MinHeapNode*));

return minHeap;

}

void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b)

{ struct MinHeapNode* t = *a;

*a = *b;

*b = t;

}

void minHeapify(struct MinHeap* minHeap, int idx)

{ int smallest = idx;

int left = 2 * idx + 1;

int right = 2 * idx + 2;

if (left < minHeap->size &&

minHeap->array[left]->freq < minHeap->array[smallest]->freq)

smallest = left;

if (right < minHeap->size &&

minHeap->array[right]->freq < minHeap->array[smallest]->freq)

smallest = right;

if (smallest != idx)

{ swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]);

minHeapify(minHeap, smallest);

} }

int isSizeOne(struct MinHeap* minHeap)

{ return (minHeap->size == 1);

}

struct MinHeapNode* extractMin(struct MinHeap* minHeap)

{ struct MinHeapNode* temp = minHeap->array[0];

minHeap->array[0] = minHeap->array[minHeap->size - 1];

--minHeap->size;

minHeapify(minHeap, 0);

return temp;

}

void insertMinHeap(struct MinHeap* minHeap, struct MinHeapNode* minHeapNode)

{ ++minHeap->size;

int i = minHeap->size - 1;

while (i && minHeapNode->freq < minHeap->array[(i - 1)/2]->freq)

{ minHeap->array[i] = minHeap->array[(i - 1)/2];

i = (i - 1)/2;

} minHeap->array[i] = minHeapNode;

}

void buildMinHeap(struct MinHeap* minHeap)

{ int n = minHeap->size - 1;

int i;

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

minHeapify(minHeap, i);

}

void printArr(int arr[], int n)

{ int i;

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

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

printf("\n");

}

int isLeaf(struct MinHeapNode* root)

{ return !(root->left) && !(root->right) ;

}

struct MinHeap* createAndBuildMinHeap(char data[], int freq[], int size)

{ int i;

struct MinHeap* minHeap = createMinHeap(size);

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

minHeap->array[i] = newNode(data[i], freq[i]);

minHeap->size = size;

buildMinHeap(minHeap);

return minHeap;

}

struct MinHeapNode* buildHuffmanTree(char data[], int freq[], int size)

{ struct MinHeapNode *left, *right, *top;

struct MinHeap* minHeap = createAndBuildMinHeap(data, freq, size);

while (!isSizeOne(minHeap))

{ left = extractMin(minHeap);

right = extractMin(minHeap);

top = newNode('$', left->freq + right->freq);

top->left = left;

top->right = right;

insertMinHeap(minHeap, top);

}

return extractMin(minHeap);

}

void printCodes(struct MinHeapNode* root, int arr[], int top)

{

if (root->left)

{ arr[top] = 0;

printCodes(root->left, arr, top + 1); }

if (root->right)

{ arr[top] = 1;

printCodes(root->right, arr, top + 1); }

if (isLeaf(root))

{ printf("%c: ", root->data);

printArr(arr, top); } }

void HuffmanCodes(char data[], int freq[], int size)

{ struct MinHeapNode* root = buildHuffmanTree(data, freq, size);

int arr[MAX_TREE_HT], top = 0;

printCodes(root, arr, top); }

int main()

{ char arr[10] ;

int size,freq[10],i;

printf("enter number of character to be encoded\n");

scanf("%d",&size);

printf("enter the character to be encoded\n") ;

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

scanf("%c",&arr[i]);

printf("enter frequncy of character to be encoded\n");

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

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

HuffmanCodes(arr, freq, size);

return 0;

}

OUTPUT:

//8.Depth First Traversal (DFS)program

#include<iostream>

#include <list>

using namespace std;

class Graph

{ int V; // No. of vertices

list<int> *adj; // Pointer to an array containing adjacency lists

void DFSUtil(int v, bool visited[]); // A function used by DFS

public:

Graph(int V); // Constructor

void addEdge(int v, int w);

void DFS(); };

Graph::Graph(int V)

{ this->V = V;

adj = new list<int>[V];

}

void Graph::addEdge(int v, int w)

{ adj[v].push_back(w); // Add w to v’s list.

}

void Graph::DFSUtil(int v, bool visited[])

{ visited[v] = true;

cout << v << " ";

list<int>::iterator i;

for(i = adj[v].begin(); i != adj[v].end(); ++i)

if(!visited[*i])

DFSUtil(*i, visited); }

void Graph::DFS()

{ bool *visited = new bool[V];

for (int i = 0; i < V; i++)

visited[i] = false;

for (int i = 0; i < V; i++)

if (visited[i] == false)

DFSUtil(i, visited);

}

int main()

{ Graph g(4);

g.addEdge(0, 1);

g.addEdge(0, 2);

g.addEdge(1, 2);

g.addEdge(2, 0);

g.addEdge(2, 3);

g.addEdge(3, 3);

cout << "Following is Depth First Traversal\n";

g.DFS();

return 0;

}

OUTPUT:

//9.Breadth First Search (BFS) program

#include<iostream.h>

#include <list.h>

using namespace std;

class Graph

{ int V;

list<int> *adj;

public:

Graph(int V);

void addEdge(int v, int w);

void BFS(int s); };

Graph::Graph(int V)

{ this->V = V;

adj = new list<int>[V];

}

void Graph::addEdge(int v, int w)

{ adj[v].push_back(w); // Add w to v’s list.

}

void Graph::BFS(int s)

{ bool *visited = new bool[V];

for(int i = 0; i < V; i++)

visited[i] = false;

list<int> queue;

visited[s] = true;

queue.push_back(s);

list<int>::iterator i;

while(!queue.empty())

{ s = queue.front();

cout << s << " ";

queue.pop_front();

for(i = adj[s].begin(); i != adj[s].end(); ++i)

{ if(!visited[*i])

{ visited[*i] = true;

queue.push_back(*i);

} } } }

int main()

{ Graph g(4);

g.addEdge(0, 1);

g.addEdge(0, 2);

g.addEdge(1, 2);

g.addEdge(2, 0);

g.addEdge(2, 3);

g.addEdge(3, 3);

cout << "Following is Breadth First Traversal (starting from vertex 2) \n";

g.BFS(2);

return 0;

}

OUTPUT:

//10. Dijkstra's shortest path algorithm

#include <stdio.h>

#include <limits.h>

#define V 9

int minDistance(int dist[], bool sptSet[])

{ int min = INT_MAX, min_index;

for (int v = 0; v < V; v++)

if (sptSet[v] == false && dist[v] <= min)

min = dist[v], min_index = v;

return min_index;

}

int printSolution(int dist[], int n)

{ printf("Vertex Distance from Source\n");

for (int i = 0; i < V; i++)

printf("%d \t\t %d\n", i, dist[i]);

}

void dijkstra(int graph[V][V], int src)

{

int dist[V]; bool sptSet[V]; for (int i = 0; i < V; i++)

dist[i] = INT_MAX, sptSet[i] = false;

dist[src] = 0;

for (int count = 0; count < V-1; count++)

{

int u = minDistance(dist, sptSet);

sptSet[u] = true;

for (int v = 0; v < V; v++)

if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX

&& dist[u]+graph[u][v] < dist[v])

dist[v] = dist[u] + graph[u][v];

}

printSolution(dist, V);

}

int main()

{ int graph[V][V] = {{0, 4, 0, 0, 0, 0, 0, 8, 0},

{4, 0, 8, 0, 0, 0, 0, 11, 0},

{0, 8, 0, 7, 0, 4, 0, 0, 2},

{0, 0, 7, 0, 9, 14, 0, 0, 0},

{0, 0, 0, 9, 0, 10, 0, 0, 0},

{0, 0, 4, 0, 10, 0, 2, 0, 0},

{0, 0, 0, 14, 0, 2, 0, 1, 6},

{8, 11, 0, 0, 0, 0, 1, 0, 7},

{0, 0, 2, 0, 0, 0, 6, 7, 0}

};

dijkstra(graph, 0);

return 0;

}

OUTPUT:

//11. Prim's Minimum Spanning Tree (MST) algorithm

#include <stdio.h>

#include <limits.h>

#define V 5

int minKey(int key[], bool mstSet[])

{ int min = INT_MAX, min_index;

for (int v = 0; v < V; v++)

if (mstSet[v] == false && key[v] < min)

min = key[v], min_index = v;

return min_index;

}

int printMST(int parent[], int n, int graph[V][V])

{ printf("Edge Weight\n");

for (int i = 1; i < V; i++)

printf("%d - %d %d \n", parent[i], i, graph[i][parent[i]]);

}

void primMST(int graph[V][V])

{ int parent[V]; // Array to store constructed MST

int key[V]; // Key values used to pick minimum weight edge in cut

bool mstSet[V]; // To represent set of vertices not yet included in MST

for (int i = 0; i < V; i++)

key[i] = INT_MAX, mstSet[i] = false;

key[0] = 0; // Make key 0 so that this vertex is picked as first vertex

parent[0] = -1; // First node is always root of MST

for (int count = 0; count < V-1; count++)

{ int u = minKey(key, mstSet);

mstSet[u] = true;

only those vertices which are not yet

for (int v = 0; v < V; v++)

if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v])

parent[v] = u, key[v] = graph[u][v];

}

printMST(parent, V, graph);

}

int main()

{ /* Let us create the following graph

2 3

(0)--(1)--(2)

| / \ |

6| 8/ \5 |7

| / \ |

(3)-------(4)

9 */

int graph[V][V] = {{0, 2, 0, 6, 0},

{2, 0, 3, 8, 5},

{0, 3, 0, 0, 7},

{6, 8, 0, 0, 9},

{0, 5, 7, 9, 0},

};

primMST(graph);

return 0;

}

OUTPUT: