Lab Assignment
Lab Assignment
Lab Assignment
-****************-
Q1) Impement the merge sort algorithm using C program.
Program:-
#include<stdio.h>
void merge(int A[],int n1,int index1,int B[],int n2,int index2,int c[],int index)
{
while(n1&&n2)
{
if(A[index1]<B[index2])
{
c[index]=A[index1];
index++;
index1++;
n1--;
}
else
{
c[index]=B[index2];
index++;
index2++;
n2--;
}
}
while(n1)
{
c[index]=A[index1];
index++;
index1++;
n1--;
}
while(n2)
{
c[index]=B[index2];
index++;
index2++;
n2--;
}
}
void mergepass(int A[],int N,int L,int B[])
{
int j,LB;
int Q,S,R;
Q=N/(2*L);
S=2*L*Q;
R=N-S;
for(j=0;j<Q;j++){
LB=(2*j)*L;
merge(A,L,LB,A,L,LB+L,B,LB);
}
if(R<=L)
{
for(j=0;j<R;j++)
{
B[S+j]=A[S+j];
}
}
else{
merge(A,L,S,A,R-L,S+L,B,S);
}
}
void merge_sort(int A[],int N)
{
int L=1,B[50];
while(L<N)
{
mergepass(A,N,L,B);
mergepass(B,N,2*L,A);
L=4*L;
}
}
int main(void)
{
int i;
int a[]={11,66,88,33,66,77,99,88,22,44,55};
for(i=0;i<=10;i++)
{
printf("%d ",a[i]);
}
merge_sort(a,11);
printf("\n");
for(i=0;i<=10;i++)
{
printf("%d ",a[i]);
}
printf("\n");
return 0;
}
Analysis:-
We tend to use Divide and Conquer approach in Merge sort algorithm.
In the Divide and Conquer approach, we first divide the array into
smaller subarrays and then merge them together to get the sorted array.
With the function mergepass we break the array into smaller subarray.
With the function merge we sort the smaller array and with merge_sort
we combine back the array together in sorted order.
Time complexibility is O(n log(n)) time in all the three cases(Best case,
Worst case and Average case).
The overall running time of Merge sort are
T(n)=2T( ) + O(n)+ O(1)
Worst Space complexity of Merge sort is O(n).
i = 0;
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++;
}
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
int main()
{
FILE *fn;
int num,n,arr[150000],a,upper,lower;
clock_t start_t, end_t;
double total_t;
printf("Enter the total number of random number : ");
scanf("%d",&n);
printf("Enter lower value: ");
scanf("%d",&lower);
printf("Enter upper value: ");
scanf("%d",&upper);
fn=fopen("number.txt","w");
srand(time(0));
for (int i=0;i<n;i++) {
num=(rand()%(upper-lower+1))+ lower;
fprintf(fn," %d",num);
}
fclose(fn);
fn = fopen("number.txt", "r");
int i;
for (i = 0; i < n; i++)
{
fscanf(fn, "%d", &arr[i]);
}
printArray(arr,n);
printf("\n-------------------------");
while(1)
{
printf("\nPress 1 to Bubble Sort the given array.");
printf("\nPress 2 to Merge Sort the given array.");
printf("\nPress any number to Exit!\n\n");
printf("Enter Your Choice : ");
scanf("%d", &a);
switch(a){
case 1:
start_t=clock();
bubbleSort(arr, n);
end_t=clock();
total_t = (double)(end_t - start_t) / CLOCKS_PER_SEC;
printf("Total time taken for execution: %f\n\n", total_t);
printf("\nBubble Sorted array:: ");
printArray(arr, n);
break;
case 2:
start_t=clock();
mergeSort(arr, 0, n - 1);
end_t=clock();
total_t = (double)(end_t - start_t) / CLOCKS_PER_SEC;
printf("Total time taken for execution: %f\n\n", total_t );
printf("\nMerge Sorted array :: ");
printArray(arr, n);
break;
default:
exit(0);
}
}
return 0;
}
Analysis:-
In order to anayse time we use “time.h” header file and clock() function
to analyse the time taken by merge sort and bubble sort.
Here, we take random data and store it in the files.
For a small number of random data the Bubble sort and Merge sort are
almost equal with respect to sorting numbers in approximately the same
time.
For a large number of random data the time complexity rate is lower in
merge sort as compared to bubble sort.
Average time complexity of Bubble sort is O( ) and of Merge sort is
O(nlog(n)).
Worst space complexity of Bubble sort is O(1) and Merge sort is O(n).
int main() {
int i;
int array[] = {44,33,11,55,77,90,40,60,99,22,88,66,110,121};
printf("Unsorted Array\n");
for (int i = 0; i < n; ++i) {
printf("%d ", array[i]);
}
printf("\n");
// perform quicksort on data
quickSort(array, 0, n - 1);
Analysis:-
Quicksort is a sorting algorithm which uses Divide and conquer
approach.
In Quicksort algorithm first we chooses a pivot and then partition the
array around pivot.
Here we choose pivot as high and perform partition(quick() function) of
array.
In the quick() function, we swap the two element with the given
condition.
At last apply the quicksort() function in recursive form to perform the
sorting element.
Time complexity of Quicksort when pivot is low and high is O( ) and
when pivot is middle is O(n log(n)) and when pivot is random element
then
T(n) = T(n-i) + i*O(n).
Worst space complexity of Quick sort is O(log(n)).
Analysis:-
In the given problem we are given point and we have to find the closest
point between them.
We take an input of point as separate array of x and y coordinate as a
and b.
Initilise the distance d as Infinity.
With the two for loop calculate the distance between two point till last
and if it is less than d then put it in d and so on.
Here the time complexity in O( ).
while(A[i]<=pivot)
{
i++;
}
while(A[j]>pivot)
{
j--;
}
if(i<j)
{
temp=A[i];
A[i]=A[j];
A[j]=temp;
}
}while(i<j);
temp=A[low];
A[low]=A[j];
A[j]=temp;
return j;
}
void quicksortl(int A[],int low,int high)
{
int partitionIndl;
if(low<high)
{
partitionIndl=partitionl(A,low,high);
quicksortl(A,low,partitionIndl-1);
quicksortl(A,partitionIndl+1,high);
}
}
void swap(int *a,int *b)
{
int temp=*a;
*a=*b;
*b=temp;
}
int partitionr(int A[],int low,int high)
{
int pivot=A[high];
int i=low-1;
int j=low;
for(j=low;j<high;j++)
{
if(A[j]<=pivot)
{
i++;
swap(&A[i],&A[j]);
}
}
swap(&A[i+1],&A[high]);
return i+1;
}
partitionInd=partitionr(A,low,high);
quicksortr(A,low,partitionInd-1);
quicksortr(A,partitionInd+1,high);
}
}
int quicksortm(int arr[],int low,int high)
{
if(low>=high)
return 0;
int mid=(low+high)/2;
int pivot=arr[mid];
int i=low,j=high;
int temp;
while(i<j)
{
if(arr[i]>=pivot && arr[j]<=pivot)
{
temp=arr[j];
arr[j]=arr[i];
arr[i]=temp;
i++;
j--;
}
else
{
i++;
}
}
quicksortm(arr,low,mid);
quicksortm(arr,mid+1,high);
}
int partitionrandom(int A[],int low,int high)
{
srand(time(NULL));
int r=low+rand()%(high-low);
int pivot=A[r];
swap(&A[r],&A[high]);
int i=low-1;
int j=low;
for(j=low;j<high;j++)
{
if(A[j]<=pivot)
{
i++;
swap(&A[i],&A[j]);
}
}
swap(&A[i+1],&A[high]);
return i+1;
}
void quicksortrandom(int A[],int low,int high)
{
int partitionInd;
if(low<high)
{
partitionInd=partitionrandom(A,low,high);
quicksortrandom(A,low,partitionInd-1);
quicksortrandom(A,partitionInd+1,high);
}
}
int main()
{
int i,A[50000];
int n;
printf("Enter the value of range:");
scanf("%d",&n);
srand(time(NULL));
for(int i=1;i<=n;i++)
{
A[i]=rand()%1000;
printf("%d ", A[i]);
}
clock_t t1,t2,t3,t4;
t1=clock();
quicksortl(A,1,n);
t1=clock()-t1;
double t5=((double)t1)/CLOCKS_PER_SEC;
printf("\n\nTime taken by Quick sort when pivot element is low is %lf
second",t5);
printf("\n");
printf("\nSorted Array of Quick sort when pivot is low:: \n");
for(i=1;i<=n;i++)
{
printf("%d ",A[i]);
}
t2=clock();
quicksortr(A,1,n);
t2=clock()-t2;
double t6=((double)t2)/CLOCKS_PER_SEC;
printf("\n\nTime taken by Quick sort when pivot element is high is %lf
second",t6);
printf("\n");
printf("\nSorted Array of Quick sort when pivot is high:: \n");
for(i=1;i<=n;i++)
{
printf("%d ",A[i]);
}
t3=clock();
quicksortm(A,1,n);
t3=clock()-t3;
double t7=((double)t3)/CLOCKS_PER_SEC;
printf("\n\nTime taken by Quick sort when pivot is middle element is %lf
second",t7);
printf("\n");
printf("\nSorted Array of Quick sort when pivot is middle:: \n");
for(i=1;i<=n;i++)
{
printf("%d ",A[i]);
}
t4=clock();
quicksortrandom(A,1,n);
t4=clock()-t4;
double t8=((double)t4)/CLOCKS_PER_SEC;
printf("\n\nTime taken by Quick sort when pivot element is random is %lf
second",t8);
printf("\n");
printf("\nSorted Array of Quick sort when pivot is random:: \n");
for(i=1;i<=n;i++)
{
printf("%d ",A[i]);
}
return 0;
}
Analysis:-
Quicksort is a sorting algorithm which uses Divide and Conquer
approach.
In Quicksort algorithm first we chooses a pivot and then partition the
array around the pivot.
We use “time.h” header file and clock() function we analyse the time
taken Quicksort when the change the pivot position to high, low, middle
and random.
Here we print we time taken by Quicksort at different pivot position to
show the variation of time by changing the pivot position.
Time complexity of Quicksort when pivot is low and high is O( ) and
when pivot is middle is O(n log(n)) and when pivot is random element
then
T(n) = T(n-i) + i*O(n)
Worst space complexity of Quicksort is O(log(n)).
:- %% Thank you %%