Merge Sort Algorithm in DSA Python - Time & Space Complexity

Time Complexity: Merge Sort Algorithm

O(n log n)

Understanding Time Complexity

We want to understand how the time taken by merge sort changes as the list to sort gets bigger.

Specifically, how many steps does merge sort take when sorting more items?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)


def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

This code splits the list into halves, sorts each half recursively, and then merges the sorted halves.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Recursive splitting of the list and merging sorted halves.
• How many times: The list is split about log₂(n) times, and merging happens at each level over all elements.

How Execution Grows With Input

Each time we split, the number of parts doubles, but each part is half the size. Merging all parts at each level touches all elements once.

Input Size (n)	Approx. Operations
10	About 10 x 4 = 40
100	About 100 x 7 = 700
1000	About 1000 x 10 = 10,000

Pattern observation: Operations grow roughly as n times log n, meaning it grows faster than linear but much slower than quadratic.

Final Time Complexity

Time Complexity: O(n log n)

This means if the list doubles in size, the time taken grows a bit more than double, but not as much as if it grew by the square of the size.

Common Mistake

[X] Wrong: "Merge sort is just like bubble sort and takes a long time because it compares every pair repeatedly."

[OK] Correct: Merge sort smartly splits the list and merges sorted parts, so it avoids repeated comparisons over the whole list, making it much faster than bubble sort.

Interview Connect

Understanding merge sort's time complexity shows you can analyze recursive algorithms and explain why they are efficient, a key skill in many coding discussions.

Self-Check

"What if we changed merge sort to split the list into three parts instead of two? How would the time complexity change?"

Practice

1. What is the main idea behind the Merge Sort algorithm?

easy

A. Swap adjacent elements repeatedly until sorted

B. Divide the list into halves, sort each half, then merge them

C. Pick the smallest element and move it to the front repeatedly

D. Build a sorted list by inserting elements one by one

Solution

1. Step 1: Understand the divide and conquer approach

   Merge Sort splits the list into smaller parts to make sorting easier.

2. Step 2: Merge sorted halves

   After sorting each half, it combines them to form a fully sorted list.

3. Final Answer:

   Divide the list into halves, sort each half, then merge them -> Option B

4. Quick Check:

   Merge Sort = Divide, sort halves, merge [OK]

Hint: Remember: split, sort halves, then merge [OK]

Common Mistakes:

• Confusing Merge Sort with Bubble Sort
• Thinking it swaps elements directly without splitting
• Assuming it sorts in one pass

2. Which of the following is the correct way to split a list arr into two halves in Python for merge sort?

easy

A. left = arr[:len(arr)//2+1]; right = arr[len(arr)//2:]

B. left = arr[1:len(arr)//2]; right = arr[len(arr)//2+1:]

C. left = arr[:len(arr)//2]; right = arr[len(arr)//2:]

D. left = arr[:len(arr)/2]; right = arr[len(arr)/2:]

Solution

1. Step 1: Use integer division for slicing

   Python list slicing requires integer indices; len(arr)//2 gives an integer midpoint.

2. Step 2: Slice correctly for left and right halves

   Left half is from start to midpoint (exclusive), right half from midpoint to end.

3. Final Answer:

   left = arr[:len(arr)//2]; right = arr[len(arr)//2:] -> Option C

4. Quick Check:

   Integer division and slicing = left = arr[:len(arr)//2]; right = arr[len(arr)//2:] [OK]

Hint: Use // for integer division in slicing [OK]

Common Mistakes:

• Using single slash / causing float index error
• Incorrect slice ranges skipping elements
• Adding +1 unnecessarily in slicing

3. What will be the output of the following code snippet?

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

print(merge_sort([4, 1, 3, 2]))

medium

A. [1, 2, 3, 4]

B. [4, 3, 2, 1]

C. [1, 3, 2, 4]

D. [2, 1, 3, 4]

Solution

1. Step 1: Recursively split and sort the list

   The list [4,1,3,2] is split into [4,1] and [3,2], then further until single elements.

2. Step 2: Merge sorted halves step-by-step

   Merge [4] and [1] to get [1,4], merge [3] and [2] to get [2,3], then merge [1,4] and [2,3] to get [1,2,3,4].

3. Final Answer:

   [1, 2, 3, 4] -> Option A

4. Quick Check:

   Sorted list = [1, 2, 3, 4] [OK]

Hint: Trace splits and merges carefully [OK]

Common Mistakes:

• Confusing merge order causing wrong output
• Not extending remaining elements after main loop
• Mixing up indices i and j

4. Identify the error in this merge function used in merge sort:

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) or j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    return result

medium

A. Using 'or' instead of 'and' in while condition causes index errors

B. Missing initialization of result list

C. Appending elements without comparing

D. Not returning the merged list

Solution

1. Step 1: Analyze the while loop condition

   Using 'or' means loop continues even if one list is exhausted, causing index out of range errors.

2. Step 2: Correct condition and handle leftovers

   The condition should be 'and' to compare elements safely, then extend remaining elements after loop.

3. Final Answer:

   Using 'or' instead of 'and' in while condition causes index errors -> Option A

4. Quick Check:

   While condition must be 'and' to avoid errors [OK]

Hint: Use 'and' in loop to avoid index errors [OK]

Common Mistakes:

• Using 'or' causing index out of range
• Not extending leftover elements after loop
• Forgetting to increment indices properly

5. You want to sort a list of tuples [(3, 'c'), (1, 'a'), (2, 'b')] by the first element using merge sort. Which modification is needed in the merge function's comparison?

hard

A. Compare using if left[i][1] < right[j][1]:

B. Use if left[i] < right[j]: without change

C. Convert tuples to strings before comparing

D. Change comparison to if left[i][0] < right[j][0]:

Solution

1. Step 1: Understand tuple comparison

   Tuples compare element-wise, but to sort by first element explicitly, compare left[i][0] and right[j][0].

2. Step 2: Modify merge comparison accordingly

   Change the if condition in merge to compare the first elements of tuples for correct sorting.

3. Final Answer:

   Change comparison to if left[i][0] < right[j][0]: -> Option D

4. Quick Check:

   Compare tuple first elements for sorting [OK]

Hint: Compare tuple elements explicitly by index [OK]

Common Mistakes:

• Comparing whole tuples without index may work but is unclear
• Comparing second element instead of first
• Converting tuples to strings unnecessarily