Quick Sort as Divide and Conquer in DSA Go - 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 independently, and then combines the results to get a sorted array.

beginner

What role does the pivot play in Quick Sort?

The pivot is a chosen element that divides the array into two parts: elements less than the pivot go to the left, and elements greater go to the right.

intermediate

Explain the three main steps of Quick Sort.

1. Choose a pivot.
2. Partition the array so elements less than pivot are left, greater are 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?

Quick Sort performs poorly, degrading to O(n²) time complexity because partitions are unbalanced and recursion depth increases.

What is the first step in Quick Sort?

A Choose a pivot element

B Merge two sorted arrays

C Swap all elements

D Reverse the array

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

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

A Swap pivot with last element

B Sort the entire array again

C Stop sorting

D Recursively sort the left and right parts

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

What is the average time complexity of Quick Sort?

A O(n²)

B O(n log n)

C O(log n)

D O(n)

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

Which of these is NOT a characteristic of Quick Sort?

A Always stable sorting

B Uses a pivot to partition

C Divide and conquer approach

D Recursive sorting of subarrays

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

What causes Quick Sort to have worst-case performance?

A Choosing the middle element as pivot

B Sorting already sorted array

C Choosing the smallest or largest element as pivot every time

D Using recursion

Picking the smallest or largest element as pivot causes unbalanced partitions and worst-case O(n²) time.

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

Think about splitting the array and sorting smaller parts.

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

Consider what happens if pivot is always smallest or largest.

Practice

1. What is the main idea behind the Quick Sort algorithm in the divide and conquer approach?

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 memory to merge two sorted arrays

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, sorts parts recursively.

2. Step 2: Compare with other sorting methods

   Unlike bubble or selection sort, Quick Sort uses division and conquering subproblems.

3. Final Answer:

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

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 or selection sort
• Thinking Quick Sort merges arrays like merge sort
• Ignoring the pivot selection step

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

easy

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

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

C. func partition(arr []int, low, high int) string

D. func partition(arr []int, low int, high int)

Solution

1. Step 1: Check Go syntax for function parameters

   In Go, slices are declared as []int, and multiple parameters can be declared with types.

2. Step 2: Verify return type for partition

   Partition returns an int index, so return type must be int.

3. Final Answer:

   func partition(arr []int, low int, high int) int -> Option A

4. Quick Check:

   Go func syntax with slice and int return = func partition(arr []int, low int, high int) int [OK]

Hint: Go slices use []type, return type must match function purpose [OK]

Common Mistakes:

• Using incorrect array syntax like int[]
• Wrong return type for partition function
• Missing return type in function declaration

3. What will be the output of the following Go code snippet after calling quickSort(arr, 0, len(arr)-1)?

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

func quickSort(arr []int, low, high int) {
    if low < high {
        pi := partition(arr, low, high)
        quickSort(arr, low, pi-1)
        quickSort(arr, pi+1, high)
    }
}

func main() {
    arr := []int{4, 2, 7, 1}
    quickSort(arr, 0, len(arr)-1)
    fmt.Println(arr)
}

medium

A. [7 4 2 1]

B. [4 2 7 1]

C. [1 2 4 7]

D. [1 4 2 7]

Solution

1. Step 1: Trace partition and quickSort on array [4, 2, 7, 1]

   Pivot is last element; after partition, smaller elements move left; recursive calls sort subarrays.

2. Step 2: Final sorted array after all recursive calls

   Array becomes [1, 2, 4, 7] after full quick sort completes.

3. Final Answer:

   [1 2 4 7] -> Option C

4. Quick Check:

   Quick Sort sorts array ascending = [1 2 4 7] [OK]

Hint: Quick Sort sorts in place; final array is sorted ascending [OK]

Common Mistakes:

• Assuming array stays unchanged
• Confusing pivot placement
• Ignoring recursive calls

4. Identify the bug in this Go Quick Sort partition function:

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

medium

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

B. Loop should start from low, not low + 1

C. Swap after loop should be arr[high], arr[i]

D. Variable i should be initialized to low - 1

Solution

1. Step 1: Analyze initialization of i in partition

   In standard Lomuto partition with pivot at arr[high], i should start at low - 1 to track smaller elements correctly.

2. Step 2: Check loop and swap logic

   Loop and swaps are correct if i starts at low - 1; current i = low causes incorrect partitioning.

3. Final Answer:

   Variable i should be initialized to low - 1 -> Option D

4. Quick Check:

   Correct i start fixes partition logic [OK]

Hint: Initialize i = low - 1 for Lomuto partition with pivot at end [OK]

Common Mistakes:

• Starting i at low causes wrong partition index
• Confusing pivot position with swap indices
• Changing pivot without adjusting i initialization

5. Given an array with many duplicate elements, which modification to Quick Sort helps improve performance and avoid worst-case behavior?

hard

A. Always choose the first element as pivot

B. Use a three-way partitioning to separate less, equal, and greater elements

C. Avoid recursion by using a single loop

D. Sort only the first half of the array

Solution

1. Step 1: Understand problem with duplicates in Quick Sort

   Duplicates cause many equal elements, leading to unbalanced partitions and slow sorting.

2. Step 2: Apply three-way partitioning solution

   Three-way partitioning divides array into less than, equal to, and greater than pivot, improving efficiency.

3. Final Answer:

   Use a three-way partitioning to separate less, equal, and greater elements -> Option B

4. Quick Check:

   Three-way partitioning handles duplicates better [OK]

Hint: Three-way partitioning handles duplicates efficiently [OK]

Common Mistakes:

• Choosing fixed pivot causes worst-case on duplicates
• Trying to avoid recursion breaks divide and conquer
• Sorting only half misses elements