Merge Sort in Python

  1. Use Recursion to Implement Merge Sort in Python
  2. Use Iterative Merge Sort in Python

Merge sort is a popular sorting algorithm utilized to sort the elements of any given data structure. This tutorial discusses the merge sort algorithm and how to implement it in Python.

Merge sort is a prime example of the divide-and-conquer approach and is utilized to sort large data sets. The algorithm begins by dividing the given data structure into two parts and then repeats the same process on both halves. Finally, it combines the halves back together to obtain sorted values efficiently. Hence, we call it a prime example of the divide-and-conquer approach.

The best part about this algorithm is that it has a consistent time complexity of O(nlogn) in all three possible cases (average case, best case, and worst case). Due to this fact, it is generally considered efficient and is preferred for large data sets.

We will now see how to implement the merge sort algorithm using the Python programming language.

Use Recursion to Implement Merge Sort in Python

Merge sort is simply implemented in Python with the help of a recursive function.

The following code uses recursion to implement merge sort in Python.

def m(left, right):
    if not len(left) or not len(right):
        return left or right
 
    result = []
    i, j = 0, 0
    while (len(result) < len(left) + len(right)):
        if left[i] < right[j]:
            result.append(left[i])
            i+= 1
        else:
            result.append(right[j])
            j+= 1
        if i == len(left) or j == len(right):
            result.extend(left[i:] or right[j:])
            break
 
    return result
 
def msort(list):
    if len(list) < 2:
        return list
 
    middle = int(len(list)/2)
    left = msort(list[:middle])
    right = msort(list[middle:])
 
    return m(left, right)
     
lst = [5, 9, 3, 7, 15, 6]
print("Given List:")
print(lst);
print("\n")
print("Sorted List:")
print(msort(lst))

The above code provides the following output:

Given List:
[5, 9, 3, 7, 15, 6]
Sorted List:
[3, 5, 6, 7, 9, 15]

Code Explanation:

  • The given list is separated into two halves, left and right in every recursive call as long as two adjacent values are not obtained.
  • The m() function is created and utilized to merge the two halves that are originally divided in the first step.
  • The msort() function carries out most of the dividing and the sorting part of the given list in the program.

Use Iterative Merge Sort in Python

The iterative merge sort algorithm is a little different from the general recursive method as the former makes use of the bottom-up approach while the latter uses the top-to-bottom approach. However, the time complexity and the final answer remain exactly the same in both methods.

Moreover, the recursive merge sort method makes use of an explicit auxiliary stack, while there is no need for it in the iterative merge sort algorithm implementation.

The following code uses the iterative merge sort algorithm to implement merge sort in Python.

def msort(a):
    width = 1   
    n = len(a)                                         
    while (width < n):
        l=0;
        while (l < n):
            r = min(l+(width*2-1), n-1)
            m = (l+r)//2
            if (width>n//2):       
                m = r-(n%width)  
            mer(a, l, m, r)
            l += width*2
        width *= 2
    return a

def mer(a, l, m, r):
    n1 = m - l + 1
    n2 = r - m
    L = [0] * n1
    R = [0] * n2
    for i in range(0, n1):
        L[i] = a[l + i]
    for i in range(0, n2):
        R[i] = a[m + i + 1]
 
    i, j, k = 0, 0, l
    while i < n1 and j < n2:
        if L[i] > R[j]:
            a[k] = R[j]
            j += 1
        else:
            a[k] = L[i]
            i += 1
        k += 1
 
    while i < n1:
        a[k] = L[i]
        i += 1
        k += 1
 
    while j < n2:
        a[k] = R[j]
        j += 1
        k += 1

a = [5, 9, 3, 7, 15, 6]
print("Given List:")
print(a)
msort(a)
print("Sorted List:")
print(a)

The above code provides the following output:

Given List:
[5, 9, 3, 7, 15, 6]
Sorted List:
[3, 5, 6, 7, 9, 15]

Disadvantages of Merge Sort

Even though merge sort is really popular and is considered to be highly efficient, it has some drawbacks in various cases, which are mentioned below.

  • When dealing with a smaller set of data structures, it can be comparatively slower than the other available sorting algorithms.
  • Extra memory space is needed to implement this algorithm.
  • The algorithm will always go through with the whole process, even when the given data structure is already sorted.
Write for us
DelftStack articles are written by software geeks like you. If you also would like to contribute to DelftStack by writing paid articles, you can check the write for us page.

Related Article - Python Sorting

  • Difference Between sort() and sorted() in Python