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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to swap two elements in the array.

DSA C++

void swap(int& a, int& b) {
    int temp = a;
    a = [1];
    b = temp;
}

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

Atemp

Ba

Cb

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning 'a' to 'temp' again instead of 'b'.

Using '0' instead of 'b'.

To swap two variables, assign 'a' the value of 'b', then 'b' the original value of 'a' stored in 'temp'.

2fill in blank

medium

Complete the code to choose the pivot element as the last element of the array segment.

DSA C++

int partition(int arr[], int low, int high) {
    int pivot = arr[[1]];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return i + 1;
}

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

Ahigh

Blow

Clow + 1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing 'low' as pivot index instead of 'high'.

Using an index outside the segment.

The pivot is chosen as the last element in the current segment, which is at index 'high'.

3fill in blank

hard

Fix the error in the recursive quickSort call to sort the left partition.

DSA C++

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, [1]);
        quickSort(arr, pi + 1, high);
    }
}

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

Api - 1

Bhigh

Cpi

Dlow

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pi' instead of 'pi - 1' causing infinite recursion.

Using 'high' which sorts the whole array again.

The left partition ends at 'pi - 1' because 'pi' is the pivot's final position.

4fill in blank

hard

Fill both blanks to complete the partition function's loop condition and swap call.

DSA C++

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j [1] high; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[[2]]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return i + 1;
}

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

A<

B<=

Ci

Dj

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<=' in loop causing out-of-bound errors.

Swapping with 'i' instead of 'j' inside the loop.

The loop runs while 'j' is less than 'high' and swaps elements at 'i' and 'j'.

5fill in blank

hard

Fill all three blanks to complete the quickSort function's recursive calls and base condition.

DSA C++

void quickSort(int arr[], int low, int high) {
    if (low [1] high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, [2]);
        quickSort(arr, [3], high);
    }
}

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

A<

Bpi - 1

Cpi + 1

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<=' in base condition causing infinite recursion.

Using 'pi' instead of 'pi - 1' or 'pi + 1' in recursive calls.

The base condition is 'low < high'. The left recursive call sorts up to 'pi - 1', and the right starts from 'pi + 1'.

Practice

1. What is the main idea behind the Quick Sort algorithm as a divide and conquer method?

easy

A. Use extra memory to merge two sorted arrays

B. Sort the array by repeatedly swapping adjacent elements

C. Divide the array into smaller parts, sort them, and combine results

D. Sort the array by selecting the smallest element each time

Solution

1. Step 1: Understand divide and conquer in Quick Sort

   Quick Sort divides the array into parts around a pivot, then sorts each part separately.

2. Step 2: Recognize the sorting and combining process

   After dividing, it sorts the parts recursively and combines them by the nature of recursion.

3. Final Answer:

   Divide the array into smaller parts, sort them, and combine results -> Option C

4. Quick Check:

   Divide and conquer = divide, sort, combine [OK]

Hint: Remember: divide, sort parts, then combine [OK]

Common Mistakes:

• Confusing Quick Sort with Bubble Sort
• Thinking Quick Sort uses extra memory like Merge Sort
• Believing Quick Sort selects smallest element each time

2. Which of the following is the correct way to declare the partition function header in C++ for Quick Sort?

easy

A. void partition(int arr[], int low, int high);

B. int partition(int arr[], int low, int high);

C. int partition(int arr, int low, int high);

D. int partition(int arr[], int start, int end, int pivot);

Solution

1. Step 1: Identify correct parameter types

   The partition function takes an array and two indices low and high to work on a subarray.

2. Step 2: Check return type

   Partition returns an integer index where the pivot finally sits.

3. Final Answer:

   int partition(int arr[], int low, int high); -> Option B

4. Quick Check:

   Partition returns int index with arr[], low, high [OK]

Hint: Partition returns pivot index, takes array and two indices [OK]

Common Mistakes:

• Using void return type for partition
• Passing array as int instead of int[]
• Adding extra parameters like pivot unnecessarily

3. What will be the output array after one partition call on arr = [4, 7, 2, 9, 1] with low=0 and high=4 if pivot is chosen as last element?

medium

A. [1, 4, 2, 7, 9]

B. [4, 7, 2, 9, 1]

C. [1, 2, 7, 9, 4]

D. [1, 7, 2, 9, 4]

Solution

1. Step 1: Choose pivot and start partitioning

   Pivot is last element: 1. There are no elements less than 1.

2. Step 2: Rearrange array around pivot

   No swaps occur in the loop since all arr[j] > 1 for j = 0 to 3. Then swap arr[0] and arr[4], resulting in [1, 7, 2, 9, 4].

3. Final Answer:

   [1, 7, 2, 9, 4] -> Option D

4. Quick Check:

   Pivot 1 placed at position 0, all to right > 1 [OK]

Hint: Pivot last element, smaller left, larger right [OK]

Common Mistakes:

• Not moving pivot to correct position
• Swapping elements incorrectly
• Assuming pivot stays at end

4. Identify the error in this Quick Sort partition code snippet:

int partition(int arr[], int low, int high) {
  int pivot = arr[high];
  int i = low;
  for (int j = low; j < high; j++) {
    if (arr[j] < pivot) {
      swap(arr[i], arr[j]);
      i++;
    }
  }
  swap(arr[i], arr[high]);
  return i;
}

medium

A. Initialization of i should be low - 1

B. Loop should run until j <= high

C. Pivot should be arr[low] instead of arr[high]

D. Swap inside if should be swap(arr[j], arr[i])

Solution

1. Step 1: Check initialization of i

   i should start at low - 1 to track last smaller element index before loop.

2. Step 2: Understand loop and swaps

   Loop runs j from low to high-1 correctly; swapping arr[i+1] and arr[high] places pivot correctly.

3. Final Answer:

   Initialization of i should be low - 1 -> Option A

4. Quick Check:

   i = low - 1 needed for correct partition [OK]

Hint: i starts before low to track smaller elements [OK]

Common Mistakes:

• Starting i at low causes wrong swaps
• Loop running to high causes out-of-bound errors
• Changing pivot position unnecessarily

5. Given an array arr = [10, 80, 30, 90, 40, 50, 70], what is the state of the array after the first full Quick Sort partition step choosing the last element as pivot?

hard

A. [10, 30, 40, 50, 70, 80, 90]

B. [10, 30, 40, 50, 70, 90, 80]

C. [10, 80, 30, 90, 40, 50, 70]

D. [10, 30, 40, 50, 80, 90, 70]

Solution

1. Step 1: Identify pivot and partition

   Pivot is last element 70. Partition rearranges elements less than 70 to left.

2. Step 2: Rearrange array after partition

   Elements less than 70: 10, 30, 40, 50. Elements greater: 80, 90. After partition, pivot 70 placed after smaller elements: [10, 30, 40, 50, 70, 80, 90]

3. Final Answer:

   [10, 30, 40, 50, 70, 80, 90] -> Option A

4. Quick Check:

   Pivot 70 placed after smaller elements [OK]

Hint: Pivot last, smaller left, pivot placed next, larger right [OK]

Common Mistakes:

• Sorting entire array in first step
• Swapping pivot with wrong element
• Assuming pivot moves to last position