Quick Sort as Divide and Conquer in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

Quick Sort divides the array into smaller parts around a pivot, sorts each part separately, and then combines them to get the sorted array.

beginner

What role does the pivot play in Quick Sort?

The pivot is a chosen element that helps split the array into two parts: elements less than the pivot and elements greater than or equal to the pivot.

intermediate

Explain the three main steps of Quick Sort.

1. Choose a pivot.
2. Partition the array so elements less than pivot go left, greater or equal go right.
3. Recursively apply Quick Sort to left and right parts.

intermediate

Why is Quick Sort considered efficient on average?

Because it divides the problem into smaller parts quickly and sorts them independently, leading to an average time complexity of O(n log n).

advanced

What happens if the pivot is always the smallest or largest element in Quick Sort?

The array is divided unevenly, causing Quick Sort to behave like a slow sorting method with time complexity O(n²).

What is the first step in Quick Sort?

A Choose a pivot element

B Merge two sorted arrays

C Swap all elements

D Find the maximum element

Quick Sort starts by choosing a pivot element to divide the array.

After partitioning around the pivot, what does Quick Sort do next?

A Recursively sort the left and right parts

B Sort the entire array again

C Stop sorting

D Swap pivot with first element

Quick Sort recursively sorts the parts left and right of the pivot.

What is the average time complexity of Quick Sort?

A O(n²)

B O(log n)

C O(n)

D O(n log n)

Quick Sort has an average time complexity of O(n log n).

Which of these is NOT a characteristic of Quick Sort?

A Divide and conquer approach

B Always stable sorting

C Uses a pivot to partition

D Recursive sorting of subarrays

Quick Sort is not stable because equal elements can change order.

What causes Quick Sort to perform poorly with O(n²) time?

A Using recursion

B Choosing the middle element as pivot

C Choosing the smallest or largest element as pivot every time

D Sorting already sorted arrays

Picking the smallest or largest element as pivot causes unbalanced splits and poor performance.

Describe how Quick Sort uses the divide and conquer method to sort an array.

Think about how the array is split and sorted in parts.

Explain why the choice of pivot affects Quick Sort's performance.

Consider what happens if the pivot is always the smallest or largest element.

Practice

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

easy

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

B. Sort the array by repeatedly swapping adjacent elements

C. Use extra space to merge two sorted arrays

D. Find the maximum element and place it at the end repeatedly

Solution

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

   Quick Sort divides the array into parts based on a pivot, sorts each part separately.

2. Step 2: Recognize the combining step

   After sorting parts, the array is combined naturally as parts are sorted in place.

3. Final Answer:

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

4. Quick Check:

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

Hint: Quick Sort splits and sorts parts separately [OK]

Common Mistakes:

• Confusing Quick Sort with Bubble Sort
• Thinking Quick Sort uses extra space like Merge Sort
• Believing Quick Sort only swaps adjacent elements

2. Which of the following is the correct way to choose a pivot in Quick Sort in Java?

easy

A. int pivot = arr[length / 2];

B. int pivot = arr[arr.length / 2];

C. int pivot = arr[arr.length];

D. int pivot = arr[-1];

Solution

1. Step 1: Identify valid pivot index

   Array indices go from 0 to length-1, so middle index is length/2.

2. Step 2: Check each option

   A uses length (undefined, invalid), B uses arr.length (out of bounds), C uses middle element (valid), D uses negative index (invalid in Java).

3. Final Answer:

   int pivot = arr[arr.length / 2]; -> Option B

4. Quick Check:

   Pivot index must be within 0 to length-1 [OK]

Hint: Pivot index must be valid array index [OK]

Common Mistakes:

• Using arr.length as index (out of bounds)
• Using negative indices (not allowed in Java)
• Always choosing first element without reason

3. What will be the output array after the first partition step of Quick Sort on int[] arr = {4, 7, 2, 9, 1} if pivot is chosen as the first element?

medium

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

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

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

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

Solution

1. Step 1: Choose pivot and partition

   Pivot = 4. Elements less than 4 go left, greater go right.

2. Step 2: Rearrange array after partition

   Left side: 2,1; pivot:4; right side:7,9. So array becomes [2, 1, 4, 7, 9].

3. Final Answer:

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

4. Quick Check:

   Partition arr around pivot 4 = [2,1,4,7,9] [OK]

Hint: Partition places pivot between smaller and larger elements [OK]

Common Mistakes:

• Not moving elements smaller than pivot to left
• Leaving array unchanged after partition
• Placing pivot at wrong position

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

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

medium

A. Variable i should start at low, not low - 1

B. Pivot should be arr[low], not arr[high]

C. Loop should run until j < high, not j <= high

D. Swap logic is incorrect

Solution

1. Step 1: Analyze loop boundary

   The loop runs j from low to high inclusive, but arr[high] is pivot and should not be compared inside loop.

2. Step 2: Correct loop condition

   Loop should run j from low to high-1 to avoid swapping pivot with itself.

3. Final Answer:

   Loop should run until j < high, not j <= high -> Option C

4. Quick Check:

   Partition loop excludes pivot index [OK]

Hint: Loop excludes pivot index during partition [OK]

Common Mistakes:

• Including pivot in partition loop
• Starting i at wrong index
• Changing pivot selection unnecessarily

5. Given the array {10, 80, 30, 90, 40, 50, 70}, if Quick Sort always chooses the last element as pivot, what is the sequence of pivot values chosen during the entire sorting process?

hard

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

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

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

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

Solution

1. Step 1: Identify pivots chosen at each recursive call

   First pivot: last element 70. After partition, left subarray ends at 50, right subarray ends at 80.

2. Step 2: Continue choosing last element as pivot in subarrays

   Next pivots: 50 (left), then 40, then 30, then 10; right subarray pivots: 80, then 90.

3. Final Answer:

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

4. Quick Check:

   Last element pivot sequence matches [OK]

Hint: Pivot is always last element in current subarray [OK]

Common Mistakes:

• Mixing pivot order with sorted array order
• Choosing first element as pivot instead
• Ignoring recursive calls on subarrays