0% found this document useful (0 votes)
86 views20 pages

095 Priyanshu Mishra, ADA Lab File

The document contains a practical file submitted by Priyanshu Mishra for the Algorithms Design and Analysis Lab course. It includes 6 programs implementing sorting and searching algorithms like insertion sort, bubble sort, selection sort, quick sort, merge sort, and linear search. For each algorithm, the program in C++ is provided along with the output and time complexity analysis of best case, worst case, and average case. The file contains an index listing the 6 experiments and serves as a record of work done for the course.

Uploaded by

Pratham Kakkar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
86 views20 pages

095 Priyanshu Mishra, ADA Lab File

The document contains a practical file submitted by Priyanshu Mishra for the Algorithms Design and Analysis Lab course. It includes 6 programs implementing sorting and searching algorithms like insertion sort, bubble sort, selection sort, quick sort, merge sort, and linear search. For each algorithm, the program in C++ is provided along with the output and time complexity analysis of best case, worst case, and average case. The file contains an index listing the 6 experiments and serves as a record of work done for the course.

Uploaded by

Pratham Kakkar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 20

PRACTICAL FILE

OF

Algorithms Design and Analysis Lab

(Paper code: ETCS-351)

Submitted to: Submitted by:


Ms. Sanjana Priyanshu Mishra
Assistant Professor 09515603120
IT Dept. Section: T7
Course: B.Tech-IT

DR. AKHILESH DAS GUPTA INSTITUTE OF TECHNOLOGY AND MANAGEMENT

NEW DELHI
INDEX

S.No Experiment Date Remarks T.Sign


1. Write a program to implement Insertion
sort using array as a data structure and
analyse it’s time complexity.

2. Write a program to implement Bubble


sort using array as a data structure and
analyse it’s time complexity.
3. Write a program to implement Selection
sort using array as a data structure and
analyse it’s time complexity.

4. Write a program to implement Quick


sort using array as a data structure and
analyse it’s time complexity.

5. Write a program to implement Merge


sort using array as a data structure and
analyse it’s time complexity.

6. Write a program to implement Linear


Search and analyse it’s time complexity.

7. Write a program to implement Binary


search and analyse it’s time complexity.

8. Write a program to implement Matrix


chain multiplication and analyse it’s time
complexity.
PROGRAM NO: 01
Program Objective: Write a program to implement Insertion sort using array as a
data structure and analyse it’s time complexity.

Program in C++:

#include <iostream>
using namespace std.
int main()
{
int n;
cout<<"Enter Number of Elements
cin>>n;
int num[n];
for(int k=0;k<n;k++)
{
cout<<"Enter Number "<<k+1<<" : ";
cin>>num[k];
}
int i,j,x;
cout<<"Array before Insertion Sort"<<endl;
for(i=0; i<n; i++)
{
cout<<num[i]<<" ";
}
for(i=1; i<n; i++)
{
x=num[i];
j=i-1;
while(j>=0)
{
if(x<num[j])
{
num[j+1]=num[j];
}
else {
break;
}
j=j-1;
}
num[j+1]=x;
}
cout<<"\nArray after Insertion Sort\n”;
for(i=0; i<n; i++)
{
cout<<num[i]<<" ";
}
return 0;
}

Output:

Time Complexity:
A. Best Case: When Array is already sorted ->
Number of Comparisons: n-1
• n: number of Elements
Therefore, Best Case Time Complexity =O(n)
B. Worst Case: Array order is in descending order ->
Number of Comparisons: n(n-1)/2
• n: number of Elements
Therefore, Worst Case Time Complexity =O(n2)
C. Average Case: Time complexity = O(n2)
PROGRAM NO: 02
Program Objective: Write a program to implement Bubble sort using array as a data
structure and analyze it’s time complexity
Program in C++:
#include<iostream>
using namespace std;
int main()
{
cout<<"\nSorting the Array using Bubble Sort Method !!!\n";
int n, i, arr[100], j, temp;
cout<<"Enter the Size of Array (max. 100): ";
cin>>n;
cout<<"Enter "<<n<<" Numbers
for(i=0; i<n; i++)
cin>>arr[i];
for(i=0; i<(n-1); i++)
{
for(j=0; j<(n-i-1); j++)
{
if(arr[j]>arr[j+1])
{
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
cout<<"\nArray Sorted Successfully !!!\n”;
cout<<"\nThe New Array is: \n";
for(i=0; i<n; i++)
cout<<arr[i]<<" ";
cout<<endl;
return 0;
}
Output:

Time Complexity:

A. Best Case: When Array is already sorted ->


Number of Comparisons: (n-1)
• n: number of Elements
Therefore, Best Case Time Complexity =O(n)
B. Worst Case: Array order is in descending order ->
Number of Comparisons: (n-1)(n-1)
• n: number of Elements
Therefore, Worst Case Time Complexity =O(n2)
C. Average Case: Time complexity = O(n2)
PROGRAM NO: 03
Program Objective: Write a program to implement Selection sort using array as a
data structure and analyze it’s time complexity

Program in C++:

#include <iostream>
using namespace std;
int main() {
int arr[10]={6,12,0,18,11,99,55,45,34,2};
int n,i, j, position, swap;
cout<<"Enter the Size of Array (max. 100): ";
cin>>n;
cout<<"Enter "<<n<<" Numbers: ";
for(i=0; i<n; i++)
cin>>arr[i];
for (i = 0; i < (n - 1); i++) {
position = i;
for (j = i + 1; j < n; j++) {
if (arr[position] > arr[j])
position = j;
}
if (position != i) {
swap = arr[i];
arr[i] = arr[position];
arr[position] = swap;
}
}
cout<<"Sorted Array is : ";
for (i = 0; i < n; i++)
cout<<arr[i]<<" ";
return 0;
}
Output:

Time Complexity:

A. Best Case: When Array is already sorted ->


Number of Comparisons: n*(n+1)/2
• n: number of Elements
Therefore, Best Case Time Complexity =O(n2)
B. Worst Case: Case when the array is already sorted (with one
swap) but the smallest element is the last element. -> Number of
Comparisons: n*(n+1)/2
• n: number of Elements
Therefore, Worst Case Time Complexity =O(n2)
C. Average Case: Time complexity = O(n2)
PROGRAM NO: 04
Program Objective: Write a program to implement Quick sort using array as a data
structure and Analyze it’s time complexity

Program in C++:

#include<iostream>
using namespace std;
void swap(int arr[] , int pos1, int pos2){
int temp;
temp = arr[pos1];
arr[pos1] = arr[pos2];
arr[pos2] = temp;
}
int partition(int arr[], int low, int high, int pivot){
int i = low;
int j = low;
while( i <= high){
if(arr[i] > pivot){
i++;
}
else{
swap(arr,i,j);
i++;
j++;
}
}
return j-1;
}
void quickSort(int arr[], int low, int high){
if(low < high){
int pivot = arr[high];
int pos = partition(arr, low, high,
pivot);

quickSort(arr, low, pos-1);


quickSort(arr, pos+1, high);
}
}
int main()
{
int n ;
cout <<"Enter the Number Of Elements : ";
cin>>n;
int arr[n];
for( int i = 0 ; i < n; i++){
cout<<"Enter Number "<<i+1<<" : ";
cin>> arr[i];
}
cout<<"Sorting the Array using Quick Sort Method !!!\n";
cout<<"The Unsorted array is: \n";
for( int i = 0 ; i < n; i++){
cout<< arr[i]<<" ";
}
quickSort(arr, 0 , n-1);
cout<<"\nThe Sorted array is: \n";
for( int i = 0 ; i < n; i++){
cout<< arr[i]<<" ";
}
}
Output:

Time Complexity:
A. Best Case: the best case of quick sort is when we will select pivot as a mean element.
Number of Operations: logn*n
• n: number of Elements
Therefore, Best Case Time Complexity =O(nlogn)
B. Worst Case: when our array will be sorted and we select smallest or largest indexed
element as pivot. ->
Number of Operations: n*(n+1)/2
• n: number of Elements
Therefore, Worst Case Time Complexity =O(n2) 3.
C. Average Case: Time complexity = O(n2)
PROGRAM NO: 05
Program Objective: Write a program to implement Merge sort using array as a data
structure and analyze it’s time complexity.

Program in C++:
#include <iostream>
using namespace std;
void merge(int arr[], int p, int q, int r)
{
int n1 = q - p + 1;
int n2 = r - q;
int L[n1], M[n2];
for (int i = 0; i < n1; i++)
L[i] = arr[p + i];
for (int j = 0; j < n2; j++)
M[j] = arr[q + 1 + j];
int i, j, k;
i = 0;
j = 0;
k = p;
while (i < n1 && j < n2)
{
if (L[i] <= M[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = M[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = M[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r)
{
if (l < r)
{
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
int main()
{
int n ;
cout <<"Enter the Number Of Elements : ";
cin>>n;
int arr[n];
for( int i = 0 ; i < n; i++){
cout<<"Enter Number "<<i+1<<" : ";
cin>> arr[i];
}
cout<<"Sorting the Array using Merge Sort Method !!!\n";
cout<<"The Unsorted array is: \n";
for( int i = 0 ; i < n; i++){
cout<< arr[i]<<" ";
}
mergeSort(arr, 0, n - 1);
cout<<"\nThe Sorted array is: \n";
for( int i = 0 ; i < n; i++){
cout<< arr[i]<<" ";
}
return 0;
}
Output:

Time Complexity:

A. Best Case: One can assume that the array is already sorted so in that case the
number of comparisons would be minimum. Number of Comparisons: n*logn
• n: number of Elements
Therefore, Best Case Time Complexity =O(nlogn)
B. Worst Case: first, divide the array into smaller parts then do comparisons on the
smaller parts and rearrange them and then perform a merging so one can say the
order which leads to the maximum number of comparisons will give us the worst
time complexity.
Number of Comparisons: n*logn
• n: number of Elements
Therefore, Worst Case Time Complexity =O(n*logn)
C. Average Case: Time complexity = O(nlogn)
PROGRAM NO: 06
Program Objective: Write a program to implement Linear Search and analyze it’s time
complexity.

Program in C++:

#include <iostream>
using namespace std;
int search(int arr[], int N, int x)
{
int i;
for (i = 0; i < N; i++)
if (arr[i] == x)
return i;
return -1;
}
int main()
{
cout<<"\nSearching The Element Using Linear Search Method !!!\n";
int arr[] = {2, 4, 0, 1, 9};
cout<<"Enter the Number You Want To Search (0-9) : ";
int x;
cin>>x;
int N = sizeof(arr) / sizeof(arr[0]);
int result = search(arr, N, x);
if (result == -1){
cout << "-> Sorry !! Element is not present in the Array";
}
else{
cout << "-> Element is present at index " << result;
}
return 0;
}
Output:

Time Complexity:

A. Best Case: The element to be search is on the first index.


Number of Comparisons: 1
Therefore, Best Case Time Complexity =O(1)
B. Worst Case: The element to be search is in the last index and the element to be search
is not present in the list
Number of Comparisons: n
• n: number of Elements
Therefore, Worst Case Time Complexity =O(n)
C. Average Case: Time complexity = O(n)
PROGRAM NO: 07
Program Objective: Write a program to implement Binary Search and analyse it’s time
complexity.

Program in C++:

#include <iostream>
using namespace std;
int binarySearch(int array[], int x, int low, int high) { while
(low <= high) {

int mid = low + (high - low) / 2;

if (array[mid] == x){
return mid;
}
if (array[mid] < x){
low = mid + 1;
}
else{
high = mid - 1;
}
}
return -1;
}
int main()
{
cout<<"\nSearching The Element Using Binary Search Method !!!\n";
int array[] = {3, 4, 5, 6, 7, 8, 9};
cout<<"Enter the Number You Want To Search (0-9) : ";
int x;
cin>>x;
int n = sizeof(array) / sizeof(array[0]);
int result = binarySearch(array, x, 0, n - 1);
if (result == -1)
cout<<"-> Sorry !! Element is not present in the Array";
else {
cout<<"Element is found at index "<< result;
}
Output:

Time Complexity:
A. Best Case: The element to be search is in the middle of the list
Number of Comparisons: 1
Therefore, Best Case Time Complexity =O(1)
B. Worst Case: The element is to search is in the first index or last index
Number of Comparisons: logn
• n: number of Elements
Therefore, Worst Case Time Complexity =O(logn)
C. Average Case: Time complexity = O(logn)
PROGRAM NO: 08
Program Objective: Write a program to implement Binary Search and analyze it’s time
complexity.

Program in C++:

#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++) //filling half table only
{
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;
cout<<"\n!!! Performing The Matrix Chain Multiplication !!!\n";
cout<<"Enter Number Of Arrays For Matrix Chain Multiplication : ";
cin>>n;
int arr[n+1];
for(int i=0;i<=n;i++){
if(i==n){
cout<<"Enter Number Of Columns In "<<n<<" Matrix : ";
cin>>arr[n];
} else{
cout<<"Enter Number Of Rows In "<<i+1<<" Matrix : ";
cin>>arr[i];
}
}
int size = n+1;
cout<<"Minimum Number Of Multiplication Of "<<n<<" Matrices Will Be
"<<MatrixChainOrder(arr,size)<<" Multiplications !!!";
}

Output:

Time Complexity:
A. Best Case: One can assume that the array is already sorted so in that case the
number of comparisons would be minimum. Number of Comparisons: n*logn
• n: number of Elements
Therefore, Best Case Time Complexity =O(n3) as there could be O(n^2) unique subproblems
to any MCM given problem and for every such sub-problem there could be O(n) splits
possible. So, it is O(n^3).
B. Worst Case: The columns of matrix A is not equal to rows of matrix B.
Number of Operations: 0
Therefore, Worst Case Time Complexity =O(0)
C. Average Case: Time complexity = O(0).

You might also like