Sunteți pe pagina 1din 40

Algorithm Analysis & Design Lab

(IT - 354)

Practical File

Submitted To: Submitted By:


Mr. Anuj Mukul Vashishtha
02516401516
BTech IT ( 6th sem )

University School Of Information, Communication and


Technology

Guru Gobind Singh Indraprastha University


(2016-2020)
INDEX
S.No. Programs
1 Write a program to implement quick sort.
2 Write a program to implement merge sort.
3 Write a program to implement counting sort.
4 Write a program to implement radix sort.
5 Write a program to implement bucket sort.
6 Write a program for median order statistics.
7 Write a program to implement disjoint sets using linked list.
8 Write a program to implement matrix chain multiplication.
9 Write a program to implement fractional knapsack problem.
10 Write a program to implement breadth first search.
11 Write a program to implement depth first search.
12 Write a program to implement kruskal algorithm.
13 Write a program to implement dijkstra algorithm.
14 Write a program to implement Floyd Warshall algorithm.
15 Write a program for string matching using finite automata method.
1) WAP to implement quick sort.
#include <bits/stdc++.h>
using namespace std;

void partition(int input[],int l,int r,int c)


{
int i=l,j=r;
while(i<c && j>c)
{
if(input[i]<input[c])
{
i++;
continue;
}
if(input[j]>=input[c])
{
j--;
continue;
}
swap(input[i],input[j]);
}
}
void quicksort(int input[],int l,int r)
{
if(l>=r)
return;
int m=(l+r)/2,i,c=0;
for(i=l;i<=r;i++)
{
if(input[i]<input[m])
c++;
}
swap(input[m],input[l+c]);
partition(input,l,r,l+c);
quicksort(input,l,l+c-1);
quicksort(input,l+c+1,r);
}
void quickSort(int input[], int size) {
quicksort(input,0,size-1);
}

int main() {
int s;
cin>>s;
int a[s];
for(int i=0;i<s;i++)
cin>>a[i];
quickSort(a,s);
cout<<endl;
for(int i=0;i<s;i++)
cout<<a[i]<<" ";
}
Time complexity :

Best case Average case Worst case

Ω(n log(n)) θ(n log(n)) O(n^2)

Output
2) WAP to implement merge sort

#include <bits/stdc++.h>
using namespace std;

void merge(int arr[], int l, int r,int m)


{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i=j=0;k=l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
void mergesort(int input[],int s,int e)
{
if(s>=e)
return;
int m=(s+e)/2;
mergesort(input,s,m);
mergesort(input,m+1,e);
merge(input,s,e,m);
}
void mergeSort(int input[], int size){
int s=0,e=size-1;
mergesort(input,s,e);
}

int main() {
int s;
cin>>s;
int a[s];
for(int i=0;i<s;i++)
cin>>a[i];
mergeSort(a,s);
cout<<endl;
for(int i=0;i<s;i++)
cout<<a[i]<<" ";
}
Time complexity :

Best case Average case Worst case

Ω(n log(n)) θ(n log(n)) O(n log(n))

Output
3) WAP to implement counting sort

#include <bits/stdc++.h>
using namespace std;
void countingsort(int a[],int n)
{
int c[100001]={0},i,b[n+1];
for(i=1;i<=n;i++)
c[a[i]]++;

for(i=1;i<=100000;i++)
c[i]+=c[i-1];

for(i=n;i>=1;i--)
{
int p=c[a[i]];
b[p]=a[i];
c[a[i]]--;
}

for(i=1;i<=n;i++)
a[i]=b[i];
}
int main()
{
int n,i;
cout<<"Enter array in range (0 to 10^5)"<<endl;
cin>>n;
int a[n+1];
for(i=1;i<=n;i++)
cin>>a[i];
countingsort(a,n);
cout<<endl<<"Sorted array is:-"<<endl;
for(i=1;i<=n;i++)
cout<<a[i]<<" ";
return 0;
}
Time complexity :

Best case Average case Worst case

Ω(n) θ(n) O(n)

Output
4) WAP to implement radix sort

#include<bits/stdc++.h>
using namespace std;
string a[10001];
void countingsort(int n,int x)
{
string b[n+1];
int h[10]={0},i;
for(i=1;i<=n;i++) // this loop updates h[]
{
int p=a[i].size()-x;
if(p<0)
h[0]++;
else
h[a[i][p]-'0']++;
}
for(i=1;i<10;i++) // frequency array
h[i]+=h[i-1];
for(i=n;i>=1;i--) // output array b[]
{
int p=a[i].size()-x;
if(p<0)
{
b[h[0]]=a[i];
h[0]--;
}
else
{
b[h[a[i][p]-'0']]=a[i];
h[a[i][p]-'0']--;
}
}
for(i=1;i<=n;i++) // copy b[] to actual array
a[i]=b[i];
}
int main()
{
int n,ma=0,i;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>a[i];
int x=a[i].size();
ma=max(ma,x);
}
for(i=1;i<=ma;i++)
countingsort(n,i);

cout<<”Sorted array is”<<endl;

for(i=1;i<=n;i++)
cout<<a[i]<<" ";
return 0;
}
Time complexity :

Best case Average case Worst case

Ω(n.ma) θ(n.ma) O(n.ma)

Output
5) WAP to implement bucket sort

#include<bits/stdc++.h>
using namespace std;
void bucketsort(double a[],int n)
{
int i,j,k=0;
vector<double> b[n];
for(i=0;i<n;i++) // 1) insert all elements
{ // in buckets
int index=n*a[i];
b[index].push_back(a[i]);
}

for(i=0;i<n;i++) // 2) sort all buckets


sort(b[i].begin(),b[i].end());

for(i=0;i<n;i++) // 3) merge the elements of buckets


{
for(j=0;j<b[i].size();j++)
a[k++]=b[i][j];
}
}
int main()
{
int n,i;
cin>>n;
double a[n];
for(i=0;i<n;i++) // all numbers in range (0,1)
cin>>a[i];
bucketsort(a,n);
cout<<"Sorted array is"<<endl;
for(i=0;i<n;i++)
cout<<a[i]<<" ";
return 0;
}
Time complexity :

Best case Average case Worst case

Ω(n+k) θ(n+k) O(n^2)

Output
6) WAP for median order statistics

#include<bits/stdc++.h>
using namespace std;
int partition(int a[],int l,int r)
{
int piv=a[r];
int i=l,j;
for (j=l;j<r;j++)
{
if (a[j]<=piv)
{
swap(a[i],a[j]);
i++;
}
}
swap(a[i],a[r]);
return i;
}
int find(int a[],int l,int r,int k)
{
if(l==r)
return a[l];
int p=partition(a,l,r);
int x=p-l+1;
if(x==k)
return a[p];
else if(x>k)
return find(a,l,p-1,k);
else
return find(a,p+1,r,k-x);
}
int main()
{
int n,k,i;
cin>>n;
int a[n+1];
for(i=1;i<=n;i++)
cin>>a[i];
cin>>k;
cout<<find(a,1,n,k);
return 0;
}
Time complexity :

Best case Average case Worst case

Ω(n) θ(n) O(n^2)

Output
7) WAP to implement disjoint set using linked list

#include <bits/stdc++.h>
using namespace std;
struct Index;
struct Node
{
int value;
Node* next;
Index* index;
};
struct Index
{
Node* head;
Node* tail;
};
unordered_map <int,Node*> add;
void make_set(int val)
{
Index* i=new Index;
i->head=new Node;
i->tail=i->head;
i->head->value=val;
i->head->next=nullptr;
i->head->index=i;
add[val]=i->head;
}
int find_set(int val)
{
Node* ptr=add[val];
return ptr->index->head->value;
}
void union_set(int p,int q)
{
Index* p1=add[p]->index;
Index* q1=add[q]->index;
Node* cur=q1->head;
while(cur!=nullptr)
{
cur->index=p1;
cur=cur->next;
}
p1->tail->next=q1->head;
p1->tail=q1->tail;
q1->head=nullptr;
q1->tail=nullptr;
delete q1;
}
int main()
{
int n,e,i;
cout<<"Enter no. of members and connections:-"<<endl;
cin>>n>>e;
for(i=1;i<=n;i++)
make_set(i);
cout<<"Initially:-"<<endl;
for(i=1;i<=n;i++)
cout<<i<<" is in set "<<find_set(i)<<endl;
cout<<endl<<"Enter connections:-"<<endl;
for(i=0;i<e;i++)
{
int u,v;
cin>>u>>v;
if(find_set(u)!=find_set(v))
union_set(u,v);
}
cout<<"Finally:-"<<endl;
for(i=1;i<=n;i++)
cout<<i<<" is in set "<<find_set(i)<<endl;
return 0;
}
Time complexity for each operation:

Make set Find set Union

O(1) O(1) O(n)

Overall

O(n)

Output
8) WAP to implement Matrix chain multiplication.

#include<bits/stdc++.h>
using namespace std;
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 n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
cout<<"Minimum number of multiplications is "<<MatrixChainOrder(a,n)<<endl;
return 0;
}
Time complexity :

Best case Average case Worst case

Ω(n^3) θ(n^3) O(n^3)

Space complexity :

O(n^2)

Output
9) WAP to implement fractional knapsack

#include<bits/stdc++.h>
using namespace std;
bool compare(pair<double,int> x,pair<double,int> y)
{
return x.first>y.first;
}
int main()
{
int n,max_weight,i;
double ans=0;
cout<<"Enter No. of items and Max. weight allowed"<<endl;
cin>>n>>max_weight;
int weight[n],profit[n];
cout<<"Enter weight of all items"<<endl;
for(i=0;i<n;i++)
cin>>weight[i];
cout<<"Enter profit of all items"<<endl;
for(i=0;i<n;i++)
cin>>profit[i];
vector <pair<double,int>> p_w(n);
for(i=0;i<n;i++)
{
p_w[i].first=(double)profit[i]/weight[i];
p_w[i].second=i;
}
sort(p_w.begin(),p_w.end(),compare);
for(i=0;i<n;i++)
{
double f=p_w[i].first;
int s=p_w[i].second;
if(max_weight>=weight[s])
{
max_weight-=weight[s];
ans+=profit[s];
}
else
{
ans+=f*max_weight;
break;
}
}
cout<<"Maximum profit :- "<<ans; return 0;}
Time complexity :

O(n log(n))

Space complexity :

O(n)

Output
10)WAP to implement breadth first search

#include<bits/stdc++.h>
using namespace std;
vector <int> adj[100001];
void bfs(int s,bool visited[])
{
queue<int> q;
q.push(s);
visited[s]=true;
while(!q.empty())
{
int p=q.front();
q.pop();
cout<<p<<" ";
int i;
for(i=0;i<adj[p].size();i++)
{
if(!visited[adj[p][i]])
{
visited[adj[p][i]]=true;
q.push(adj[p][i]);
}
}
}
}
int main()
{
int v,e,i;
cout<<"Enter No. of vertices and edges in the Graph :-"<<endl;
cin>>v>>e;
cout<<"Enter the edges :-"<<endl;
for(i=0;i<e;i++)
{
int u,v;
cin>>u>>v;
adj[u].push_back(v);
adj[v].push_back(u);
}
bool visited[v+1]={false};
cout<<"Breadth first search :-"<<endl;
bfs(1,visited);
return 0;
}
Time complexity :

O(V+E)

Space complexity :

O(V+E)

Output
11) WAP to implement depth first search

#include<bits/stdc++.h>
using namespace std;
vector <int> adj[100001];
void dfs(int s,bool visited[])
{
cout<<s<<" ";
visited[s]=true;
for(int i=0;i<adj[s].size();i++)
{
if(!visited[adj[s][i]])
dfs(adj[s][i],visited);
}
}
int main()
{
int v,e,i;
cout<<"Enter No. of vertices and edges in the Graph :-"<<endl;
cin>>v>>e;
cout<<"Enter the edges :-"<<endl;
for(i=0;i<e;i++)
{
int u,v;
cin>>u>>v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cout<<"Depth first search :-"<<endl;
bool visited[v+1]={false};
dfs(1,visited);
return 0;
}
Time complexity :

O(V+E)

Space complexity :

O(V+E)

Output
12) WAP to implement Kruskal algorithm

#include<bits/stdc++.h>
using namespace std;
int m[100001];
struct edge
{
int s;
int e;
int wt;
};
bool compare(edge a,edge b)
{
return a.wt<b.wt;
}
void make_set(int val)
{
m[val]=val;
}
int find_set(int val)
{
if(m[val]==val)
return val;
m[val]=find_set(m[val]);
return m[val];
}
void union_set(int p,int q)
{
m[q]=p;
}
int main()
{
int v,e,i;
cout<<"Enter No. of Vertices and Edges:-"<<endl;
cin>>v>>e;
for(i=0;i<=v;i++)
{
make_set(i);
}
edge input[e];
cout<<"Enter the Edges with weights:-"<<endl;
for(i=0;i<e;i++)
{
cin>>input[i].s>>input[i].e>>input[i].wt;
if(input[i].s>input[i].e)
swap(input[i].s,input[i].e);
}
sort(input,input+e,compare);
cout<<"Edges of MST using Kruskal Algorithm are:-"<<endl;
for(i=0;i<e;i++)
{
int p1,p2;
p1=find_set(input[i].s);
p2=find_set(input[i].e);
if(p1==p2)
continue;
union_set(p1,p2);
cout<<input[i].s<<" "<<input[i].e<<" "<<input[i].wt<<endl;
}
return 0;
}
Time complexity :

O(E log(E))

Space complexity :

O(V)

Output
13) WAP to implement Dijkstra algorithm

#include <bits/stdc++.h>
using namespace std;
void dijkstra(int** edge,int v)
{
int i,j;
int ans[v];
bool visited[v];
ans[0]=0;
visited[0]=false;
for(i=1;i<v;i++)
{
ans[i]=INT_MAX;
visited[i]=false;
}
for(j=0;j<v-1;j++)
{
int pos=-1;
for(i=0;i<v;i++) // find vertex (pos) with smallest ans[]
{
if(visited[i]==false && (pos==-1 || ans[pos]>ans[i]))
pos=i;
}
visited[pos]=true;
for(i=0;i<v;i++) // relaxation for all adjacent vertex to (pos)
{
if(edge[pos][i]!=0 && visited[i]==false)
{
if(ans[pos]+edge[pos][i]<ans[i])
ans[i]=ans[pos]+edge[pos][i];
}
}
}
for(i=0;i<v;i++)
cout<<i<<" "<<ans[i]<<endl;
}
int main()
{
int v,e,i,j;
cout<<"Enter No. of Vertices and Edges:-"<<endl;
cin>>v>>e;
int** edge=new int*[v];
for(i=0;i<v;i++)
{
edge[i]=new int[v];
for(j=0;j<v;j++)
edge[i][j]=0;
}
cout<<"Enter the edges:-"<<endl;
while(e--)
{
int v1,v2,wt;
cin>>v1>>v2>>wt;
edge[v1][v2]=wt;
edge[v2][v1]=wt;
}
cout<<"Shortest path from source vertex 0 to all other vertices is:-"<<endl;
dijkstra(edge,v);
return 0;
}
Time complexity :

O(V^2)

Space complexity :

O(V)

Output
14) WAP to implement Floyd warshall algorithm

#include<bits/stdc++.h>
using namespace std;
#define MAX 100000
void floyd_warshall(int** edge,int v)
{
int i,j,k;
for(k=0;k<v;k++)
{
for(i=0;i<v;i++)
{
for(j=0;j<v;j++)
{
if(edge[i][k]+edge[k][j]<edge[i][j])
edge[i][j]=edge[i][k]+edge[k][j];
}
}
}
cout<<"The following matrix shows shortest path between all pairs of vertices";
for(i=0;i<v;i++)
{
cout<<endl;
for(j=0;j<v;j++)
{
if(edge[i][j]==MAX)
cout<<"INF "; // means no path from i to j
else
cout<<edge[i][j]<<" ";
}
}
}
int main()
{
int v,e,i,j;
cout<<"Enter No. of Vertices and Edges:-"<<endl;
cin>>v>>e;
int** edge=new int*[v];
for(i=0;i<v;i++)
{
edge[i]=new int[v];
for(j=0;j<v;j++)
(i==j)?edge[i][j]=0:edge[i][j]=MAX;
}
cout<<"Enter the edges:-"<<endl;
while(e--)
{
int v1,v2,wt;
cin>>v1>>v2>>wt;
edge[v1][v2]=wt;
edge[v2][v1]=wt;
}
floyd_warshall(edge,v);
return 0;
}
Time complexity :

O(V^3)

Space complexity :

O(V^2)

Output
15) WAP for string matching using finite automata.

#include <bits/stdc++.h>
using namespace std;
string s,p;
int compare(deque <char> prefix,deque <char> suffix) //O(m^2)
{
int i,j,sz=prefix.size();
while(1)
{
for(i=0;i<prefix.size();i++)
{
if(prefix[i]!=suffix[i])
break;
}
if(i==prefix.size())
return sz-prefix.size();
prefix.pop_back();
suffix.pop_front();
}
}
int finite_automata()
{
if(p.size()>s.size())
return -1;
int state[p.size()+1][256],i,j;
deque <char> prefix,suffix;
for(i=0;i<=p.size();i++) // O(m^3)
{
prefix.push_back(p[i]);
for(j=0;j<256;j++)
{
suffix.push_back(j);
int diff=compare(prefix,suffix);
state[i][j]=i-diff+1;
suffix.pop_back();
}
suffix.push_back(p[i]);
}
int cstate=0;
for(i=0;i<s.size();i++) // O(n)
{
cstate=state[cstate][s[i]];
if(cstate==p.size())
return i-p.size()+1;
}
return -1;
}
int main()
{
cout<<"Enter the string and the pattern:-"<<endl;
cin>>s>>p; // if n=s.size() and m=p.size(), then
int ans=finite_automata(); // Time complexity=O(n+m^3)
if(ans!=-1)
cout<<"Pattern found at index "<<ans;
else
cout<<"Pattern not found";
return 0;
}
Time complexity :

O(s.size()+m^3)

Space complexity :

O(p.size())

Output

S-ar putea să vă placă și