Pimpri Chinchwad Education

Trust’s Pimpri Chinchwad

Polytechnic (An Record No:
ISO 9001:2015 Certified
Institute)
Sector no26, Pradhikaran Nigdi, Revision No: - 00
Pune – 4411044
Phone: - 27658797/2654156
Email: - Date: -
[email protected]

MICRO-PROJECT REPORT (PART

B)
TITLE OF MICROPROJECT:
Develop a program for merge sort using array.

GROUP NO: 04
GROUP MEMBERS:
Roll no Name of Students Enrollment no

16 Gargi Garad 2200560287

17 Karan Karvekar 2200560288

18 Prasad Pilke 2200560289

19 Shivam Raut 2200560290

20 Nikhil Chaudhari 2200560291

1
This Is To Certify That Mr. /Ms. Gargi Garad, Karan Karvekar, Prasad Pilke, Shivam Raut and Nikhil Chaudhari
group of Diploma in Information Technology. Pimpri Chinchwad Polytechnic (Code: 0056) has
completed Micro Project of the course as prescribed in the curriculum for the academic year 2023-2024.

Place: Nigdi, Akurdi

Date:

Course in charge Head of the department

Ms.Madhavi Mali

2
1. INTRODUCTION :-
Merge Sort is a Divide and Conquer algorithm. It divides the input array into two halves,
calls itself for the two halves, and then it merges the two sorted halves. The merge()function
is used for merging two halves. The sub-lists are divided again and again into halves until
the list cannot be divided further. Then we combine the pair of one element lists into two-
element lists, sorting them in the process. The sorted two-element pairs is merged into the
four-element lists, and so on until we get the sorted list.

Time Complexity: O(N log(N)), Merge Sort is a recursive algorithm and time complexity
can be expressed as following recurrence relation.

Auxiliary Space: O(N), In merge sort all elements are copied into an auxiliary array. So N
auxiliary space is required for merge sort.

2. AIM :-
To sort array elements by using merg sort algorithm.

3. INTENDED COURSE OUTCOME:-

CO A: - Perform basic operations on arrays.
CO C: - Apply different searching and sorting techniques.

4. ACTUAL METHODOLOGY USED :-

1. We finalize the topic with the help of micro project guide.

2. We distributed sub topic between the members.
3. Everyone did their work accurately.
4. All the information was submitted to the leader.
5. All the sub-topic was arranged in specific order.
6. Final project was given to respective in charge within the time limit.

3
 5. RESOURCES / MATERIAL REQUIRED :-

SR. RESOURCES SPECIFICATION QTY REMARK

NO.

1 Internet 4G, 5G 120 mb/s ✓

2 Computer Lenovo S145,Intel core-i3,8GB 1 ✓

Ram,2.00GHz 64bit OS,1Tb HDD

3 Software DevC++

6. REPORT :-
i. Introduction:-
It is one of the most popular sorting algorithms used in computer science, and it is
fundamental to understand for both freshers and professionals alike. In this article,
we will give you a rundown of the basics of merge sort, from analyzing complexity
to understanding advantages and disadvantages. We will also provide a visual
example and explain the pseudocode involved in the process.

At its core, merge sort operates using a divide and conquer strategy. This means that
it takes a large dataset and splits it into smaller pieces so that they can be sorted
more easily. To achieve this, divide array recursively until individual elements are
formed. Once these individual elements are formed, they can then be merged
together in sorted subarrays which eventually result in a completely sorted array.

When analyzing the complexity of merge sort, it follows an O(n log n) process
meaning that as the size of datasets increase, so too does its running time
accordingly. As such, in relation to other sorting algorithms (e.g., bubble sort or
insertion sort), it is considered one of the faster sorting algorithms out there. Despite
its efficiency however, there are certain disadvantages to bear in mind when using
merge sort such as its storage requirements (it requires a large amount of extra space
due to splitting) and its inability to adapt itself for partially sorted data sets (the
entire list must be split each time).

4
ii. Algorithm Of Merg Sort :-
Step 1:Start
Step 2:Declare an array of MAX elements
Step 3: Declare mergSort function with one integre array & 2 integre as parameter
Step 4: Declare merge function with 1 integre array & 3 integer as parameter
Step 5: Aceept the unsorted array in declared array.
Step 6: Call mergeSort function.
Step 7: Display sorted array.
Step 8: Stop.
iii. Flowchart:-

5
iv. Program To Implement Merge Sort:-
/*Program for sorting array elements using merg & sort algorithm*/

#include<stdio.h>
#include<conio.h>
#define MAX 30

void mergeSort(int[],int,int);// to cut the array in 2 list

void merge(int[],int,int,int);// to merge the divided array in Sorted order

int main()
{
int data[MAX];
int i,n;
int lower,upper;

printf("\n How many elements:");

scanf("%d",&n);

lower=0;
upper=n-1;

// Aceept the array

element clrscr();

printf("\n Enter unsorted

array.."); for(i=0;i<n;i++)

6
 {
printf("\n Enter %d element:",i+1);
scanf("%d",&data[i]);
}

// display unsorted array

printf("\n Unsorted Array..");
for(i=0;i<5;i++)
printf("\n %d",data[i]);

// call mergeSort function

mergeSort(data,0,4);

// display Sorted Array

printf("\n\n Sorted Array..");

for(i=0;i<5;i++)
printf("\n %d",data[i]);

getch();
return 0;
}
void mergeSort(int data[],int lower,int upper)
{

7
 int mid;

if(lower<upper)
{
mid=(lower+upper)/2;
mergeSort(data,lower,mid);
mergeSort(data,mid+1,upper);
merge(data,lower,mid,upper);
}
}
void merge(int data[],int lower,int mid,int upper)
{
int c[MAX];
int i,j,k;

i= lower;
j= mid+1;
k=0;

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

{
if(data[i]<data[j])
{
c[k]=data[i];
k++;
i++;
}

8
 else
{

c[k]=data[j];
k++;
j++;
}
}
while(i<=mid)
{
c[k]=data[i];
i++;
k++;
}
while(j<=upper)
{
c[k]=data[j];
k++;
j++;
}
for(i=lower,j=0;i<=upper;i++,j++)
{
data[i]=c[j];

}
}

9
v. Output of Program

10
vi. Diagramic Representation

11
12
13
14
15
16
17
vii. Overview of Merge Sort Algorithm

Merge sort algorithm is a key concept in computer science which helps to sort elements
of an array. It falls under the category of comparison based sorting, or divide and conquer
algorithms, using recursive calls to divide a given array into two halves until the
subarrays consist of single elements. This sorting method has logarithmic complexity and
is considered relatively efficient and stable.
It involves repeatedly splitting a list or array into two halves, sorting each half and then
merging the sorted halves back together. By breaking down the data into smaller chunks,
merge sort can quickly and efficiently sort any input data set.

viii. Conclusion

It is a divide and conquer method of sorting. Merge sort is a sorting where best,worst
and average case time complexities are the same.

ix. Advantages of merg sort

 Stability: Merge sort is a stable sorting algorithm, which means it maintains the relative.
order of equal elements in the input array.

 Guaranteed worst-case performance: Merge sort has a worst-case time complexity of

O(N logN), which means it performs well even on large datasets.

Parallelizable: Merge sort is a naturally parallelizable algorithm, which means it can be

easily parallelized to take advantage of multiple processors or threads.

x. Drawbacks of Merge Sort

 Space complexity: Merge sort requires additional memory to store the merged sub-
arrays during the sorting process.

 Not in-place: Merge sort is not an in-place sorting algorithm, which means it requires
additional memory to store the sorted data. This can be a disadvantage in
applications where memory usage is a concern.

 Not always optimal for small datasets: For small datasets, Merge sort has a higher time
complexity than some other sorting algorithms, such as insertion sort. This can result
in slower performance for very small datasets.

18
xi. Applications of Merge Sort

 Sorting large datasets: Merge sort is particularly well-suited for sorting large
datasets due to its guaranteed worst-case time complexity of O(n log n).

 External sorting: Merge sort is commonly used in external sorting, where the data to
be sorted is too large to fit into memory.

 Custom sorting: Merge sort can be adapted to handle different input distributions,
such as partially sorted, nearly sorted, or completely unsorted data.

 Inversion Count Problem.

19
7. Skill Developed / learning out of this Micro-Project:-

Sr.no TECHNICAL/NON-TECHNICAL SKILLS TICK MARK FOR

DEVELOPED
SKILLS
1 Skill of Information Collection ✔

2 Skill of Information Analysis ✔

3 Skill of Design of Project ✔

4 Skill of Leadership ✔

5 Skill of Team Management ✔

6 Skill of Planning ✔

7 Skill of Critical Thinking ✔

8 Skill of Task Management ✔

9 Skill of Creativity ✔

10 Skill of Develop Project in deadline driven ✔

environment

11 Any other skill developed ✔

Ms. Madhavi Mali

(Course Co-coordinator)

20