Quick Sort Partition Lomuto and Hoare in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the Lomuto partition scheme in Quick Sort?

Lomuto partition picks the last element as pivot and rearranges the array so that elements smaller than pivot come before it, and larger come after. It uses a single index to track the boundary between smaller and larger elements.

intermediate

How does the Hoare partition scheme differ from Lomuto's in Quick Sort?

Hoare partition uses two indices starting from both ends moving towards each other, swapping elements that are on the wrong side of the pivot. It usually picks the first element as pivot and can be more efficient with fewer swaps.

beginner

In Lomuto partition, what happens after the partitioning is done?

The pivot element is placed in its correct sorted position, with all smaller elements to its left and larger to its right. This divides the array into two parts for recursive sorting.

intermediate

Why might Hoare partition be preferred over Lomuto partition in some cases?

Hoare partition often performs fewer swaps and can be faster because it stops when the two indices cross, not necessarily placing the pivot at the exact final position immediately.

advanced

Show the basic Go code snippet for Lomuto partition function.

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

Which element is typically chosen as pivot in Lomuto partition?

A Random element

B Last element

C Middle element

D First element

Lomuto partition usually picks the last element as the pivot.

In Hoare partition, what happens when the two indices cross?

A Partitioning ends

B Swap pivot with left index

C Restart partitioning

D Pivot is placed at the end

Partitioning ends when the two indices cross in Hoare partition.

Which partition scheme generally uses fewer swaps?

A Hoare

B Lomuto

C Both equal

D Depends on array size

Hoare partition usually performs fewer swaps than Lomuto.

What is the main purpose of partitioning in Quick Sort?

A To find the maximum element

B To sort the entire array immediately

C To divide array around pivot for recursive sorting

D To merge two sorted arrays

Partitioning divides the array around the pivot to recursively sort subarrays.

In Lomuto partition, what does the index 'i' represent?

A End of array

B Pivot position

C Current element being compared

D Boundary between smaller and larger elements

'i' tracks the boundary between elements smaller than pivot and others.

Explain how Lomuto partition rearranges the array around the pivot.

Think about how the last element is used and how smaller elements are moved.

Describe the steps of Hoare partition and why it might be more efficient.

Focus on the movement of two pointers and when partitioning stops.

Practice

1. What is the main difference between Lomuto and Hoare partition schemes in Quick Sort?

easy

A. Lomuto uses a single pointer to partition, Hoare uses two pointers moving inward

B. Lomuto sorts the array in descending order, Hoare sorts in ascending order

C. Lomuto requires extra memory, Hoare works in-place

D. Lomuto always picks the last element as pivot, Hoare always picks the first

Solution

1. Step 1: Understand Lomuto partition

   Lomuto partition uses one pointer to track the boundary of smaller elements and swaps elements accordingly.

2. Step 2: Understand Hoare partition

   Hoare partition uses two pointers starting from both ends moving inward to swap elements around the pivot.

3. Final Answer:

   Lomuto uses a single pointer to partition, Hoare uses two pointers moving inward -> Option A

4. Quick Check:

   Partition pointers = single vs two [OK]

Hint: Remember: Lomuto single pointer, Hoare two pointers inward [OK]

Common Mistakes:

• Confusing pivot selection with partition method
• Thinking Lomuto uses two pointers
• Assuming Hoare needs extra memory

2. Which of the following is the correct Lomuto partition function header in Go?

easy

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

B. func lomutoPartition(arr []int) int

C. func lomutoPartition(arr []int, pivot int) int

D. func lomutoPartition(arr []int, start int, end int) bool

Solution

1. Step 1: Check parameters needed for Lomuto

   Lomuto partition requires the array and indices low and high to define the subarray.

2. Step 2: Check return type

   It returns an integer index of the pivot after partitioning.

3. Final Answer:

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

4. Quick Check:

   Function signature = arr, low, high, returns int [OK]

Hint: Lomuto needs array and low, high indices, returns pivot index [OK]

Common Mistakes:

• Omitting low and high parameters
• Returning bool instead of int
• Passing pivot as parameter explicitly

3. What is the output array after applying Lomuto partition on [8, 3, 7, 6, 2] with pivot as last element?

medium

A. [8, 3, 7, 6, 2]

B. [3, 2, 7, 6, 8]

C. [2, 3, 7, 6, 8]

D. [2, 3, 6, 7, 8]

Solution

1. Step 1: Identify pivot and initialize pointers

   Pivot is last element 2. Initialize i = low - 1 = -1.

2. Step 2: Iterate and swap elements smaller than pivot

   Check elements: 8 > 2 no swap, 3 > 2 no swap, 7 > 2 no swap, 6 > 2 no swap. i stays -1. Finally swap pivot with arr[i+1] = arr[0].

3. Final Answer:

   [2, 3, 6, 7, 8] -> Option D

4. Quick Check:

   Pivot 2 placed at start, smaller elements left [OK]

Hint: Pivot last element, swap smaller left, pivot next [OK]

Common Mistakes:

• Swapping elements incorrectly
• Not updating i pointer properly
• Confusing pivot position after partition

4. Given this Hoare partition code snippet in Go, what is the bug?

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

medium

A. The inner loops should use <= and >= instead of < and >

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

C. i and j initialization should be i = low, j = high

D. The swap should happen after checking i > j

Solution

1. Step 1: Check pointer initialization

   In Hoare partition, i starts at low and j at high, not outside the array bounds.

2. Step 2: Understand loop conditions

   Starting i at low - 1 and j at high + 1 causes index out of range errors during arr[i] and arr[j] access.

3. Final Answer:

   i and j initialization should be i = low, j = high -> Option C

4. Quick Check:

   Pointer start = low, high [OK]

Hint: Hoare pointers start at low and high, not outside [OK]

Common Mistakes:

• Initializing pointers outside array bounds
• Using wrong pivot element
• Swapping before pointer check

5. You want to sort an array with many duplicate elements efficiently. Which partition scheme is better and why?

hard

A. Lomuto, because it handles duplicates by placing them all on one side

B. Hoare, because it partitions elements more evenly and reduces swaps with duplicates

C. Lomuto, because it uses two pointers to handle duplicates quickly

D. Hoare, because it always picks the last element as pivot

Solution

1. Step 1: Consider duplicate handling in Lomuto

   Lomuto tends to put duplicates on one side, causing unbalanced partitions and more recursive calls.

2. Step 2: Consider duplicate handling in Hoare

   Hoare's two-pointer approach partitions more evenly, reducing swaps and improving performance with duplicates.

3. Final Answer:

   Hoare, because it partitions elements more evenly and reduces swaps with duplicates -> Option B

4. Quick Check:

   Duplicates handled better by Hoare [OK]

Hint: Hoare partitions evenly, better for duplicates [OK]

Common Mistakes:

• Assuming Lomuto is better for duplicates
• Confusing pivot choice with partition efficiency
• Ignoring swap count impact