Quick Sort as Divide and Conquer in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to choose the pivot element as the last element of the slice.

DSA Go

pivot := arr[[1]]

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

Alen(arr) - 1

B0

Clen(arr) / 2

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 selects the first element, not the last.

Using len(arr)/2 selects the middle element, not the last.

The pivot is chosen as the last element of the slice, which is at index len(arr) - 1.

2fill in blank

medium

Complete the code to swap elements at indices i and j in the slice.

DSA Go

arr[[1]], arr[j] = arr[j], arr[[1]]

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

A0

Bj

Ci

Dlen(arr) - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping with the same index twice.

Using j for both sides causes no change.

To swap elements at indices i and j, use arr[i], arr[j] = arr[j], arr[i].

3fill in blank

hard

Fix the error in the partition function to correctly increment the index i.

DSA Go

if arr[j] < pivot {
    i[1]
    arr[i], arr[j] = arr[j], arr[i]
}

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

A = 1

B += 1

C++

D -= 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using i++ inside an expression causes syntax error.

Using i = 1 resets i instead of incrementing.

In Go, to increment i by 1, use i += 1. The ++ operator is a statement, not an expression, so it cannot be used inside another statement.

4fill in blank

hard

Fill both blanks to complete the recursive quicksort calls on sub-slices.

DSA Go

quickSort(arr[:[1]])
quickSort(arr[[2]:])

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

ApivotIndex

BpivotIndex + 1

CpivotIndex - 1

Dlen(arr)

Attempts:

3 left

💡 Hint

Common Mistakes

Including the pivot element in both recursive calls.

Using pivotIndex instead of pivotIndex - 1 for left slice.

The left sub-slice is from start to pivotIndex - 1, and the right sub-slice is from pivotIndex + 1 to the end.

5fill in blank

hard

Fill all three blanks to define the partition function signature and return statement.

DSA Go

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

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

Aint

B += 1

Ci + 1

Dvoid

Attempts:

3 left

💡 Hint

Common Mistakes

Using void as return type causes error.

Returning i instead of i + 1.

Using i++ which is invalid in this context.

The partition function returns an int index. Increment i by 1 using i += 1. Return i + 1 as the pivot's final position.

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