Quick Sort's behaviour depends heavily on how you partition the array, and the two most common approaches—Lomuto and Hoare—move elements around in surprisingly different ways.

In this article, we'll understand both schemes visually, implement them in Java, and compare them.

Understanding Quick Sort

Quick Sort is a divide-and-conquer sorting algorithm. Instead of sorting the entire array at once, it repeatedly picks a pivot, partitions the array around that pivot, and recursively sorts the resulting subarrays. For this reason, it is sometimes called partition-exchange sort.

The algorithm follows three simple steps:

1. Choose a pivot element.

2. Partition the array so that smaller elements move to one side and larger elements move to the other.

3. Repeat the process on both partitions until each subarray contains one or zero elements.

Initially, this seems straightforward. However, the most important part of Quick Sort is how the partitioning is performed. After partitioning, every element smaller than the pivot will appear on its left, while larger elements will appear on its right. The exact arrangement depends on the partitioning strategy used.

Partitioning

Partitioning is the crucial step in Quick Sort. Instead of sorting the entire array in one pass, Quick Sort first rearranges the elements around a pivot. After partitioning, every element smaller than the pivot ends up on one side, while every larger element ends up on the other.

The exact order of elements within each side doesn't matter yet. The goal is only to split the array into two smaller problems that can be solved recursively.

Take this array, for example :

[8, 3, 1, 7, 0, 10, 2, 5] Let the Pivot be 5.

Before Partitioning ->

After Partitioning ->

The array might look like this. Notice that all the elements on the left of the pivot are less than it, while the elements on the right of the pivot are greater than it.

[3, 1, 0, 2, 5, 10, 7, 8]

Now, how do we move the elements around the pivot? The answer depends on the partitioning strategy. As said earlier, there are two partitioning schemes: Lomuto and Hoare. Lomuto uses a growing boundary with a single scanning pointer, while Hoare uses two pointers moving toward each other.

Lomuto Partitioning Scheme

The Lomuto Partition Scheme approaches partitioning by maintaining a growing boundary of elements that belong before the pivot. As it scans the array from left to right, every element smaller than or equal to the pivot is moved into this growing region.

Lomuto uses one scanning pointer (j) and one boundary pointer (i).

For this walkthrough, we'll use the same array introduced earlier.

[8, 3, 1, 7, 0, 10, 2, 5] Pivot = 5 (last element)

Before the algorithm begins, each pointer has a specific responsibility.

• i marks the boundary of elements that are already smaller than or equal to the pivot.

• j Scans the array from left to right, examining one element at a time.

Initially,

• i = low - 1

• j = low

Initially, i = -1, and j is at low. We have marked the low and high pointers as 0 and the last index(n - 1), respectively, where n is the length of the array.

• The blue arrow (i) sits before the array because no elements have been placed into the "smaller" region yet.

• The orange arrow (j) begins scanning from the first element.

Step-By-Step Execution:

1. [8, 3, 1, 7, 0, 10, 2, 5] i = -1, j = 0 -> element at j = 8; 8 is greater than pivot (8 > 5), so nothing changes. Move j.

2. [8, 3, 1, 7, 0, 10, 2, 5] i = -1, j = 1 -> element at j = 3 -> 3 is smaller than pivot (3 < 5), so -> i++ and swap a[i] and a[j].

1. Continue scanning and swapping. The algorithm uses the same rule.

• j= 2 -> 1 -> swap

• j= 3 -> 7 -> skip

• j= 4 -> 0 -> swap

• j= 5 -> 10 -> skip

• j= 6 -> 2 -> swap

After j finishes scanning the array, all smaller elements have already been grouped.

The only remaining step is placing the pivot between the two regions.

Before the final swap:

[3, 1, 0, 2, 8, 10, 7, 5]

Swap arr[i + 1] with the pivot.

Final result:

[3, 1, 0, 2, 5, 10, 7, 8]

Java Implementation

static int lomutoPartition(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++;
            swap(arr, i, j);
        }
    }

    swap(arr, i + 1, high);
    return i + 1;
}

Throughout the algorithm, one invariant always remains true:

• Everything before i is already less than or equal to the pivot.

• Everything between i + 1 and j - 1 is greater than the pivot.

• Everything after j has not been processed yet.

Recursive calls in Lomuto

quickSort(arr, low, p - 1);
quickSort(arr, p + 1, high);

Hoare Partitioning Scheme

While Lomuto grows a boundary from left to right, Hoare Partition takes a completely different approach. Instead of expanding a single region, it places two pointers at opposite ends of the array and moves them toward each other.

Whenever the left pointer finds an element that belongs on the right, and the right pointer finds an element that belongs on the left, the two elements are swapped. This continues until the pointers cross, at which point the array has been successfully partitioned.

One important distinction is that Hoare does not guarantee that the pivot ends up in its final sorted position after partitioning. Instead, it returns a partition boundary, and the recursive calls continue from there.

We'll use the same array as before.

[8, 3, 1, 7, 0, 10, 2, 5] Pivot = 8

Unlike Lomuto, the pivot is chosen as the first element. Many practical implementations choose the middle element as the pivot to reduce the chances of poor partitions on already sorted inputs, even though Hoare's original partition scheme uses the first element.

Before the algorithm begins:

• i starts before the first element and moves right.

• j starts after the last element and moves left.

Initially,

• i = low - 1

• j = high + 1

Step-by-step execution

1. Initially, the array is -> [8, 3, 1, 7, 0, 10, 2, 5] ; i moves right and finds an element greater than the pivot, while j moves left and finds an element smaller than the pivot.
   Here, the element at i = 0 (8) is equal to the pivot, and the element at j = 7 is smaller than the pivot (5 < 8). Swap them.

   Array after swapping -> [5, 3, 1, 7, 0, 10, 2, 8]

2. Continue Searching. The pointers repeat the same process.

   i Now moves until it reaches 10.

   j moves left until it reaches 2.

   Swap them.

3. The search continues. Eventually, i >= j. At this moment, partitioning is complete.
   Instead of moving the pivot again, the algorithm simply returns. j.

The important takeaway is that the pivot (8) is not guaranteed to be in its final sorted position.

The returned value (j) simply marks where the array has been divided.

Java Implementation

static int hoarePartition(int[] arr, int low, int high) {
    int pivot = arr[low];
    int i = low - 1;
    int j = high + 1;

    while (true) {

        do {
            i++;
        }
        while (arr[i] < pivot);

        do{
            j--;
        }
        while (arr[j] > pivot);

        if (i >= j)
            return j;

        swap(arr, i, j);
    }
}

Recursive calls in Hoare

Unlike Lomuto, Hoare returns a partition boundary, so the recursive calls are slightly different.

quickSort(arr, low, p);
quickSort(arr, p + 1, high);

Lomuto vs Hoare: Comparison

Both Lomuto and Hoare partition an array around a pivot, but they work differently. Lomuto grows a boundary from left to right, while Hoare moves two pointers toward each other.

Comparison Table

If you're learning Quick Sort for the first time, Lomuto is usually easier to reason about because the pivot finishes in its final position after partitioning. Hoare, however, often performs fewer swaps, which is why many implementations prefer it in practice.