Merge Sort Algorithm in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to split the list into two halves.

DSA Python

mid = len(arr) [1] 2

Drag options to blanks, or click blank then click option'

A//

B-

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using / which returns a float and causes errors when slicing lists.

We use integer division (//) to find the middle index so that it is an integer.

2fill in blank

medium

Complete the code to recursively sort the left half of the list.

DSA Python

left_sorted = merge_sort(arr[1]:mid)

Drag options to blanks, or click blank then click option'

A{

B(

C[

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses or curly braces which are not valid for slicing.

We use square brackets [] to slice the list from start to mid.

3fill in blank

hard

Fix the error in the merge step to append the smaller element.

DSA Python

if left[i] [1] right[j]:
    merged.append(left[i])
    i += 1

Drag options to blanks, or click blank then click option'

A>

B<

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using > which would append the larger element first.

Using == or != which do not compare size.

We append the smaller element, so we check if left[i] is less than right[j].

4fill in blank

hard

Fill both blanks to complete the loops that add remaining elements after merging.

DSA Python

while i [1] len(left):
    merged.append(left[i])
    i += 1
while j [2] len(right):
    merged.append(right[j])
    j += 1

Drag options to blanks, or click blank then click option'

A<

B<=

C>

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= which can cause index out of range errors.

Using > or >= which are incorrect for loop conditions.

We continue while i and j are less than the lengths of their lists to add remaining elements.

5fill in blank

hard

Fill all three blanks to complete the merge_sort function header, base case, and return statement.

DSA Python

def merge_sort(arr):
    if len(arr) [1] 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    merged = []
    i = j = 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
    while i < len(left):
        merged.append(left[i])
        i += 1
    while j < len(right):
        merged.append(right[j])
        j += 1
    return [2]

Drag options to blanks, or click blank then click option'

A<=

Barr

Cmerged

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of <= in base case causing infinite recursion.

Returning the wrong variable instead of merged.

The base case checks if length is less than or equal to 1, then returns the merged sorted list.

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