Insertion Sort, Merge Sort. Time complexity of all sorting algorithms and their comparison.

ESIT137: Fundamentals of Data Structure
Sanjivani Rural Education Society’s
Sanjivani College of Engineering, Kopargaon-423603
(An Autonomous Institute Affiliated to Savitribai Phule Pune University, Pune)
NACC ‘A’ Grade Accredited, ISO 9001:2015 Certified
Department of Information Technology
(UG Programme - NBAAccredited)
Dr. M.A. Jawale
Professor and Head, Dept. of IT

Searching and Sorting
 Sorting Algorithms
 Insertion Sort,
 Merge Sort.
 Time complexity of all sorting algorithms and their comparison.
 References
Unit-II: Part-III Searching and Sorting Dr. Madhuri Jawale Department of Information Technology

Insertion Sort
 Insertion sort is a simple sorting algorithm that works similarly to the way you
sort playing cards in your hands.
 The array is virtually split into a sorted and an unsorted part. Values from the
unsorted part are picked and placed in the correct position in the sorted part.

Insertion Sort Algorithm
 To sort an array of size N in ascending order iterate over the array and compare
the current element (key) to its predecessor, if the key element is smaller than its
predecessor, compare it to the elements before.
 Move the greater elements one position up to make space for the swapped
element.

Working of Insertion Sort algorithm
 Consider an example: arr[]: {12, 11, 13, 5, 6}
 First Pass:
 Initially, the first two elements of the array are compared in insertion sort.
 Here, 12 is greater than 11 hence they are not in the ascending order and 12 is
not at its correct position. Thus, swap 11 and 12.
 So, for now 11 is stored in a sorted sub-array.

Continue….
 Second Pass:
 Now, move to the next two elements and compare them.
 Here, 13 is greater than 12, thus both elements seems to be in ascending order,
hence, no swapping will occur. 12 also stored in a sorted sub-array along with
11.
 Third Pass:
 Now, two elements are present in the sorted sub-array which are 11 and 12
 Moving forward to the next two elements which are 13 and 5

Continue….
 Both 5 and 13 are not present at their correct place so swap them.
 After swapping, elements 12 and 5 are not sorted, thus swap again.
 Here, again 11 and 5 are not sorted, hence swap again
 Here, 5 is at its correct position

Continue….
 Fourth Pass:
 Now, the elements which are present in the sorted sub-array are 5, 11 and 12
 Moving to the next two elements 13 and 6
 Clearly, they are not sorted, thus perform swap between both.
 Now, 6 is smaller than 12, hence, swap again.

Continue….
 Now, the elements which are present in the sorted sub-array are 5, 11 and 12
 Here, also swapping makes 11 and 6 unsorted hence, swap again.
 Finally, the array is completely sorted.

Continue….

Continue….
/* Function to sort an array using insertion sort*/
void insertionSort(int arr[], int n)
{
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
/* Move elements of arr[0..i-1], that are
greater than key, to one position ahead
of their current position */
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}

Continue….
// function to print an array of size n
void printArray(int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("n");
}
/* Driver program to test insertion sort */
int main()
{
int arr[] = { 12, 11, 13, 5, 6 };
int n = sizeof(arr) / sizeof(arr[0]);
insertionSort(arr, n);
printArray(arr, n);
return 0;
}

Complexity Analysis of Insertion Sort
 Time Complexity of Insertion Sort:
 The worst-case time complexity of the Insertion sort is O(N2
)
 The average case time complexity of the Insertion sort is O(N2
)
 The time complexity of the best case is O(N).
 Space Complexity of Insertion Sort:
 The auxiliary space complexity of Insertion Sort is O(1)

Characteristics of Insertion Sort
 This algorithm is one of the simplest algorithms with a simple implementation
 Basically, Insertion sort is efficient for small data values
 Insertion sort is adaptive in nature, i.e. it is appropriate for data sets that are
already partially sorted.

Merge Sort
 Merge sort is defined as a sorting algorithm that works by dividing an array into
smaller subarrays, sorting each subarray, and then merging the sorted subarrays
back together to form the final sorted array.
 In simple terms, we can say that the process of merge sort is to divide the array
into two halves, sort each half, and then merge the sorted halves back together.
This process is repeated until the entire array is sorted.

How does Merge Sort work?
 Merge sort is a recursive algorithm that continuously splits the array in half until
it cannot be further divided i.e., the array has only one element left (an array with
one element is always sorted). Then the sorted subarrays are merged into one
sorted array.
 Lets consider an array arr[] = {38, 27, 43, 10}
Initially divide the array into two equal halves:

How does Merge Sort work?
 Lets consider an array arr[] = {38, 27, 43, 10}
 Initially divide the array into two equal halves:

Continue….
 These subarrays are further divided into two halves. Now they become array
of unit length that can no longer be divided and array of unit length are
always sorted.

Continue….
 These sorted subarrays are merged together, and we get bigger sorted
subarrays.

Continue….
 This merging process is continued until the sorted array is built from the
smaller subarrays.

Continue….
// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
// Create temp arrays
int L[n1], R[n2];
// Copy data to temp arrays L[] and R[]
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1 + j];
// Merge the temp arrays back into arr[l..r
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++;
}

Continue….
// Copy the remaining elements of L[],
// if there are any
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
// Copy the remaining elements of R[],
// if there are any
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
// l is for left index and r is right index of the
// sub-array of arr to be sorted
void mergeSort(int arr[], int l, int r)
{
if (l < r) {
int m = l + (r - l) / 2;
// Sort first and second halves
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}

Continue….
// Function to print an array
void printArray(int A[], int size)
{
int i;
for (i = 0; i < size; i++)
printf("%d ", A[i]);
printf("n");
}
// Driver code
int main()
{
int arr[] = { 12, 11, 13, 5, 6, 7 };
int arr_size = sizeof(arr) / sizeof(arr[0]);
printf("Given array is n");
printArray(arr, arr_size);
mergeSort(arr, 0, arr_size - 1);
printf("nSorted array is n");
printArray(arr, arr_size);
return 0;
}

Complexity Analysis of Merge Sort
 Time Complexity: O(N log(N)), Merge Sort is a recursive algorithm and time
complexity can be expressed as following recurrence relation.
T(n) = 2T(n/2) + θ(n)
 Auxiliary Space: O(N), In merge sort all elements are copied into an auxiliary
array. So N auxiliary space is required for merge sort.

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.

Advantages of Merge 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(NlogN), 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.

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.

Comparison among Bubble Sort, Selection Sort and Insertion Sort
 Bubble Sort:
 Time complexity: O(n2) in the worst and average cases, O(n) in the best case
(when the input array is already sorted)
 Space complexity: O(1)
 Basic idea: Iterate through the array repeatedly, comparing adjacent pairs of
elements and swapping them if they are in the wrong order. Repeat until the
array is fully sorted..

 Selection Sort:
 Time complexity: O(n2
) in all cases (worst, average, and best)
 Basic idea: Find the minimum element in the unsorted portion of the array and
swap it with the first unsorted element. Repeat until the array is fully sorted.

 Insertion Sort:
 Time complexity: O(n2
) in the worst and average cases, O(n) in the best case
(when the input array is already sorted)
 Basic idea: Build up a sorted subarray from left to right by inserting each new
element into its correct position in the subarray. Repeat until the array is fully
sorted.

Reference
1. Richard F. Gilberg & Behrouz A. Forouzan, “Data Structures: A Pseudocode
Approach with C, Second Edition”, Cengage Learning.
2. Ellis Horowitz, Sartaj Sahani, Susan Anderson-Freed “Fundamentals of Data
Structures in C”, Universities Press, 2008.

Insertion Sort, Merge Sort. Time complexity of all sorting algorithms and their comparison.

Recommended

More Related Content

What's hot (20)

Similar to Insertion Sort, Merge Sort. Time complexity of all sorting algorithms and their comparison. (20)

Recently uploaded (20)

Insertion Sort, Merge Sort. Time complexity of all sorting algorithms and their comparison.