Merge sort is an efficient, stable sorting algorithm that works by recursively dividing an array into smaller subarrays, sorting each subarray, and then merging them back together in a sorted order. It has a time complexity of O(nlogn) and space complexity of O(n), making it faster than quadratic sorting algorithms like bubble sort and insertion sort.
In technical interviews, candidates are often asked to implement common algorithms like merge sort to evaluate their coding skills and analytical thinking. This article will provide a stepbystep guide on implementing merge sort in Python. We will cover the following:
Table of Contents
Open Table of Contents
Overview of Merge Sort
Merge sort is a divideandconquer algorithm that recursively splits an array into smaller subarrays, sorts each subarray, and then merges them back to produce the final sorted array. It operates in a bottomup approach as follows:
 If the array has 0 or 1 elements, it is already sorted  return the array
 Otherwise, split the array recursively into two halves until each subarray has 1 element
 Sort and merge the subarrays in a bottomup manner until the full array is sorted
 Return the sorted full array
The key steps are:
 Divide the array into two halves recursively until each subarray has 1 element
 Conquer by sorting the subarrays in bottomup order
 Combine the subarrays with a merge function
This “divide and conquer” strategy allows merge sort to efficiently sort the array in O(nlogn) time complexity. The tradeoff is it requires extra O(n) space complexity to store the divided subarrays temporarily during the merge phase.
Python Implementation of Merge Sort
Here is a stepbystep implementation of merge sort in Python:
1. Recursive Merge Sort Function
We first define a recursive merge_sort
function that takes in an array and recursively divides it into halves:
def merge_sort(arr):
# Base case
if len(arr) <= 1:
return arr
# Recursively divide array into halves
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
# Merge the sorted halves
return merge(left, right)
 The base case checks if the array is empty or has 1 element, in which case it is already sorted so we simply return the array.
 Otherwise, we use integer division
//
to find the midpoint and recursively divide the array into equal left and right halves.  We recursively call
merge_sort
on each half and then call themerge
function to combine the sorted halves.
2. Merge Function
The merge
function merges the two sorted subarrays:
def merge(left, right):
# Create an empty list to store the merged values
merged = []
# Iterate over left and right lists until one is empty
i, j = 0, 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
merged.append(left[i])
i += 1
else:
merged.append(right[j])
j += 1
# Append remaining elements if any
merged += left[i:]
merged += right[j:]
return merged
 We initialize an empty list
merged
to store the sorted elements.  Using two indices
i
andj
, we iterate over both subarrays comparing elements at each index.  At each step, we append the smaller element to
merged
and increment the index.  Once we reach the end of either array, we append the remaining elements of the other array.
 Finally, we return the merged sorted array.
3. Driver Code
The driver code calls the merge sort function on the array:
arr = [5,4,3,2,1]
print(merge_sort(arr))
# Output: [1,2,3,4,5]
We can now use the merge_sort
function to sort any arrays in Python.
Analysis of Merge Sort in Python
Let’s analyze the time and space complexity of this implementation:
Time Complexity
 The merge sort algorithm has overall time complexity of O(nlogn).
 The divide steps take O(logn) time as the array is split recursively in halves each time. There are logn levels of recursion.
 The merge steps take O(n) time as we iterate over all n elements once.
 Therefore, the total time is O(nlogn).
Space Complexity
 We are recursively creating logn subarrays, each of size n/2 + n/4 + … + 1 = n.
 So the extra space needed is O(n).
Therefore, this implementation has optimal O(nlogn) time with a tradeoff of using auxiliary O(n) space.
Testing the Merge Sort Implementation
We can test our implementation with different input arrays to verify it works correctly:
import random
arr1 = [5,4,3,2,1]
arr2 = list(reversed(range(10)))
arr3 = [random.randint(1,30) for _ in range(20)]
print(merge_sort(arr1)) # [1,2,3,4,5]
print(merge_sort(arr2)) # [0,1,2,3,4,5,6,7,8,9]
print(merge_sort(arr3)) # Sorted array
We test it on a descending array, ascending array, and random array of integers to ensure it correctly sorts arrays of different sizes and distributions.
Applications and Use Cases of Merge Sort
Merge sort is useful in many applications:

Sorting large data sets  Its O(nlogn) time makes merge sort suitable for sorting large arrays or data sets where performance is critical.

External sorting  Merge sort is applied in external sorting where data is too large to fit in memory and is sorted by reading/writing chunks from disk.

Inversion count  Used in counting inversions in an array which has applications in areas like estimating data complexity.

Sorting linked lists  Can be adapted to sort linked lists by using pointers instead of slicing array.

Parallel processing  Its divideandconquer approach allows parallelization to improve performance in multicore systems.
Overall, merge sort is a versatile sorting algorithm commonly used in data analysis, databases, data science, and other backend applications.
Comparison with Other Sorting Algorithms
How does merge sort compare with other common sorting algorithms?

It has a faster time complexity of O(nlogn) compared to O(n2) for bubble sort and insertion sort. But it is slower than O(n) optimal algorithms like counting sort that can be used when range of elements is limited.

It requires O(n) extra space for the auxiliary array. Algorithms like heapsort and quicksort can sort inplace needing only O(1) space.

It has better average case performance compared to quicksort while worst case is similar. Quicksort is generally faster in practice.

It is stable maintaining the relative order of equal elements. Algorithms like heapsort and quicksort are unstable.

It lends itself better to parallel processing compared to algorithms like quicksort.
So in summary, merge sort provides a good balance of time performance, stability, and parallelizability for sorting large arrays where auxiliary space is available.
Conclusion
Implementing merge sort from scratch is a common technical interview coding challenge assessing knowledge of algorithms. This guide covered a stepbystep Python implementation with complexity analysis, testing, use cases, and comparisons.
Key points to remember:
 Uses a “divide and conquer” strategy to recursively split array and merge sorted halves
 Has optimal O(nlogn) time and O(n) space complexity
 Stable sort that maintains element order
 Applicable for sorting large data and external sorting
 Parallelizable to achieve faster performance
With this comprehensive walkthrough, you should now be able to implement merge sort efficiently in Python and have a deeper understanding of its algorithmic foundations that can be applied in technical interviews and coding challenges.