Merge Sort as Divide and Conquer in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find the middle index for dividing the array.

DSA C++

int mid = (left [1] right) / 2;

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

A-

B+

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction instead of addition.

Using multiplication which gives wrong middle.

Forgetting to divide by 2.

We add left and right indices and divide by 2 to find the middle index.

2fill in blank

medium

Complete the code to recursively call mergeSort on the left half.

DSA C++

mergeSort(arr, left, [1]);

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

Aleft

Bright

Cmid

Dmid + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using right instead of mid.

Using mid + 1 which is for the right half.

Using left as end index which does not divide the array.

The left half is from left to mid, so we pass mid as the end index.

3fill in blank

hard

Fix the error in the merge function call to merge two halves.

DSA C++

merge(arr, left, mid, [1]);

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

Amid

Bmid - 1

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using mid instead of right as the last index.

Using mid - 1 which is before mid.

Using left which is the start index.

The merge function merges from left to mid and mid+1 to right, so right is the last index.

4fill in blank

hard

Fill both blanks to complete the mergeSort base condition and recursive call.

DSA C++

if (left [1] right) return;
mergeSort(arr, [2], mid);

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

A>=

B<=

Cleft

Dmid + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<=' in base case which causes infinite recursion.

Using mid + 1 instead of left for left half start.

Confusing base case condition.

Base case stops when left is greater or equal to right. Recursive call on left half uses left as start.

5fill in blank

hard

Fill all three blanks to complete the mergeSort recursive calls and merge step.

DSA C++

mergeSort(arr, left, [1]);
mergeSort(arr, [2], right);
merge(arr, left, [3], right);

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

Amid

Bmid + 1

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Using left instead of mid for left half end.

Using mid instead of mid+1 for right half start.

Using wrong middle index in merge.

Left half ends at mid, right half starts at mid+1, merge uses mid as middle index.

Practice

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

easy

A. Select a pivot and partition the array around it

B. Sort the array by repeatedly swapping adjacent elements

C. Divide the array into halves, sort each half, then merge them

D. Insert elements one by one into a sorted list

Solution

1. Step 1: Understand the divide and conquer approach

   Merge Sort splits the array into two halves recursively until single elements remain.

2. Step 2: Merge sorted halves

   After splitting, it merges the halves back in sorted order to form the sorted array.

3. Final Answer:

   Divide the array into halves, sort each half, then merge them -> Option C

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 Merge Sort uses a pivot like Quick Sort
• Believing Merge Sort sorts in place without merging

2. Which of the following is the correct base case condition in a typical Merge Sort implementation in C++?

easy

A. if (start > end) return;

B. if (start < end) return;

C. if (start == end + 1) return;

D. if (start >= end) return;

Solution

1. Step 1: Identify when to stop recursion

   The base case is when the subarray has one or zero elements, meaning start index is greater or equal to end index.

2. Step 2: Match condition to code

   The condition if (start >= end) return; correctly stops recursion when the subarray cannot be divided further.

3. Final Answer:

   if (start >= end) return; -> Option D

4. Quick Check:

   Base case = start >= end [OK]

Hint: Stop recursion when start is not less than end [OK]

Common Mistakes:

• Using start > end misses single element subarray
• Using start == end + 1 is incorrect indexing
• Using start < end returns too early

3. What will be the output of the following C++ code snippet using Merge Sort on array {4, 1, 3, 2}?

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1, n2 = r - m;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++) L[i] = arr[l + i];
    for (int j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) arr[k++] = L[i++];
        else arr[k++] = R[j++];
    }
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
}

void mergeSort(int arr[], int l, int r) {
    if (l >= r) return;
    int m = l + (r - l) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
}

int main() {
    int arr[] = {4, 1, 3, 2};
    int n = 4;
    mergeSort(arr, 0, n - 1);
    for (int i = 0; i < n; i++) std::cout << arr[i] << " ";
    return 0;
}

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: Trace recursive splitting and merging

   The array splits into [4,1] and [3,2], then further into single elements. Each pair is merged sorted: [1,4] and [2,3].

2. Step 2: Final merge

   Merging [1,4] and [2,3] results in [1,2,3,4]. The output prints this sorted array.

3. Final Answer:

   1 2 3 4 -> Option A

4. Quick Check:

   Sorted array = 1 2 3 4 [OK]

Hint: Merge Sort always outputs sorted array [OK]

Common Mistakes:

• Confusing merge order causing wrong output
• Forgetting to merge after recursive calls
• Printing array before sorting completes

4. Identify the bug in this Merge Sort merge function snippet:

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1, n2 = r - m;
    int L[n1], R[n2];
    for (int i = 0; i <= n1; i++) L[i] = arr[l + i];
    for (int j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) arr[k++] = L[i++];
        else arr[k++] = R[j++];
    }
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
}

medium

A. The loop 'for (int i = 0; i <= n1; i++)' causes out-of-bounds access

B. The merge condition should be 'L[i] < R[j]' instead of '<='

C. The arrays L and R should be dynamically allocated

D. The indices i and j should start from 1, not 0

Solution

1. Step 1: Check loop bounds for copying left array

   The loop uses 'i <= n1', which runs one extra iteration causing out-of-bounds access since valid indices are 0 to n1-1.

2. Step 2: Correct loop condition

   The loop should be 'i < n1' to copy exactly n1 elements without overflow.

3. Final Answer:

   The loop 'for (int i = 0; i <= n1; i++)' causes out-of-bounds access -> Option A

4. Quick Check:

   Loop bounds must be less than array size [OK]

Hint: Check array loops use < not <= for indexing [OK]

Common Mistakes:

• Using <= instead of < in loops
• Starting indices at 1 instead of 0
• Ignoring dynamic allocation but it's not mandatory here

5. Given an array {5, 3, 8, 6, 2, 7, 4, 1}, how many total merge operations will be performed during a full Merge Sort?

hard

A. 15

B. 7

C. 8

D. 4

Solution

1. Step 1: Understand merge operations in Merge Sort

   Merge Sort splits the array until single elements, then merges pairs stepwise. For n=8 elements, merges happen at each level combining subarrays.

2. Step 2: Calculate total merges

   Number of merges = n - 1 = 8 - 1 = 7 merges in total to combine all elements into one sorted array.

3. Final Answer:

   7 -> Option B

4. Quick Check:

   Total merges = n - 1 = 7 [OK]

Hint: Total merges in Merge Sort = array size minus one [OK]

Common Mistakes:

• Counting merges as number of elements
• Confusing merges with recursive calls
• Assuming merges double at each level