# Sorting by combining Insertion Sort and Merge Sort algorithms

Insertion sort: The array is virtually split into a sorted and an unsorted part. Values from the unsorted part are picked and placed at the correct position in the sorted part.**Advantages:** Following are the advantages of insertion sort:

- If the size of the list to be sorted is small, insertion sort runs faster
- Insertion sort takes O(N) time when elements are already sort
- It is an in-place algorithm O(1), no auxiliary space is required

Merge sort: Merge Sort is a Divide and Conquer algorithm. It divides the input array into two halves, calls itself for the two halves, and then merges the two sorted halves.

**Advantages: **Following are the advantages of merge sort:

- The division of the main problem into sub-problem has no major cost

From the above two comparisons, the advantages of both the sorting algorithms can be combined, and the resulting algorithm will have time complexity O(N[K+log(N/K)]). Below is the derivation of the time complexity of this combined algorithm:

Let, no. of elements in the list = N**Divide**:

- We first divide these N elements into (N/K) groups of size K

**Sorting**:

- For each division of subarray of size K, perform the insertion sort operation to sort this subarray
- The total cost of insertion sort for a single bock of K elements:
- For best case: O(K)
- For worst case: O(

- Since there are (N/K) such blocks each of size K, we get the total cost of applying insertion sort as:
- For best case: (N/K) * K = O(N) <– (1)
- For worst case: (N/K) * K^{2} = O(NK) <– (2)

**Merging**:

- After applying Insertion sort on (N/K) groups each of K sorted elements
- For merging these (N/K) groups:

- Let’s say we take i iterations of merge sort. So, for the loop to stop we will need to equate as:
- (2^i) * K = N
- (2^i) = N/K
- i*log(2) = log(N/K) Taking log on both sides
- i = log(N/K)
- Cost of merging = O(N)
- Total cost of merging = No. of iteration * Cost of iteration
- = log(N/K)*N
- = N*log(N/K)
- = O(N*Log(N/K)) <– (3)

The total cost of the algorithm (insertion + merge) is:

- Best case: N+Nlog(N/K) <– from (1) and (3)
- Worst case: NK + Nlog(N/K) <– from (2) and (3)

If K = 1, then it is complete merge sort which is better in terms of time complexity

If K = N, then it is complete Insertion sort which is better in terms of space complexity