Comparing Array Partition Algorithms11 Jan 2021
Partitioning an array involves moving all elements that satisfy some predicate to one side of the array. The most common example is partitioning an array of numbers based on a pivot number, so that all elements on the left side of the array are less than or equal to the pivot, while all elements on the right are greater than the pivot. This specific procedure is crucial for quicksort, a popular and efficient sorting algorithm. The more general partition based on an arbitrary predicate is useful for a wide range of divide-and-conquer style problems.
Partitioning an array can be done in-place (i.e. rearranging elements within the given array without making a copy) using constant space and linear time. That is, partition uses the same amount of memory regardless of the size of the input, and its running time increases proportionally to the number of elements in the given array. The two most common algorithms are Lomuto’s Partition and Hoare’s Partition (created by Nico Lomuto and Tony Hoare, respectively). In an NDC 2016 talk, Andrei Alexandrescu introduces an alternative algorithm which he showed was more efficient for a variety of data distributions.
This focuses on partition in the context of quicksort. We’ll implement, visualize, and time these algorithms. Then, we’ll try to tease apart what makes one slower or faster than the other. All the code to produce the timings, animations, and plots in this post can be found here.
Below is a typical implementation of
lomuto_partition as would be used in
quicksort. Our inputs are the array of numbers
arr, the array start index
lo, and the array end index
hi. Throughout this article, we can assume
hi=len(arr)-1. For algorithms like quicksort, we want to partition
a contiguous subsection of the array, which is why the start and end indices
are required. This functions returns the index at which the pivot element ends
up in our partitioned array.
def lomuto_partition(arr, lo, hi): pivot = arr[hi] for j in range(lo, hi): if arr[j] <= pivot: arr[lo], arr[j] = arr[j], arr[lo] lo += 1 arr[lo], arr[hi] = arr[hi], arr[lo] return lo
We first choose the rightmost element as the pivot. In practice, we can choose
any element to be the pivot, but for this post, we’ll keep it simple and just
lo to be the pivot.
On a high level, we have two indices
lo. We ensure that every element
to the left of
lo is less than or equal to the pivot (invariant A). Also,
ensure every element between
j is greater than the pivot (invariant
B). Elements to the right of
j are unexplored.
j encounters an element smaller or equal to the pivot, it swaps it
with the element at
lo. We then increment
lo. This way,
incremented beyond an element less than or equal to the pivot, maintaining
invariant A. We know the element currently at
j is greater than the pivot.
Why? Since that element was previously between
j, this implies that
j passed over it in a previous iteration. If it was passed before but does
not appear to the left of
lo (i.e. was not swapped), that means it is not
less than or equal to the pivot, thus it must be greater, thus maintaining
After the main loop, we swap the pivot from the end into its rightful place between the two sections, and return the index at which it was placed.
If talking about indices confuses you, here’s a visualization of this algorithm
running on a sample array. The heights of each bar represents the value of the
element at that index. Light gray elements are less than or equal to the pivot,
while black elements are greater. In red two pointers,
j, are in red,
while the pivot element is in blue.
We see our invariants being held here. We can also observe some extra work happening: some elements are swapped multiple times unnecessarily. Our next algorithm avoids this extra work by swapping each element at most once.
Lomuto’s partition maintains two pointers that splits the array into three sections: less than or equal, greater, and unexplored. Hoare’s partition also maintains two pointers, but splits the array into less than or equal, unexplored, and greater.
def hoare_partition(arr, lo, hi): pivot_ind, pivot = hi, arr[hi] hi -= 1 while True: while arr[lo] <= pivot and lo < hi: lo += 1 while arr[hi] > pivot and lo < hi: hi -= 1 if lo < hi: arr[lo], arr[hi] = arr[hi], arr[lo] lo += 1 hi -= 1 else: if arr[lo] <= pivot: lo += 1 arr[pivot_ind], arr[lo] = arr[lo], arr[pivot_ind] return lo
Our two pointers this time are
lo moves from the left to the
right, stopping when an element is greater than the pivot.
hi moves from the
right towards the left, stopping when an element is less than or equal to the
pivot. Once both pointers reach an element violating their side’s condition,
they swap, then proceed.
At the end, we do some clean-up, then swap the pivot into the dividing point then return that index.
Once again, a visualization:
The code is slightly more complex, but this time, no work is wasted: each element is swapped at most once, which is optimal. However, our code has a lot of bounds checking, which is wasteful. Our next approach solves this issue.
Hoare’s partition is optimal in terms of swaps, but it does lot of array bounds checking when incrementing the pointers. Alexandrescu’s partition uses a sentinel to avoid excessively checking the indices.
Consider this loop from Hoare’s partition:
while arr[lo] <= pivot and lo < hi: lo += 1
If we knew for sure that we would encounter an
arr[lo] > pivot before
hi, we wouldn’t need to check
lo < hi. To ensure this, we simply plant a
sentinel value at the end of the array which is greater than pivot. This way,
we know the loop will break at that element before
lo goes out of bounds.
Now, the code:
def alexandrescu_partition(arr, lo, hi): pivot_ind, pivot = lo, arr[lo] old_arr_hi, arr[hi] = arr[hi], pivot+1 while True: lo += 1 while arr[lo] <= pivot: lo += 1 arr[hi] = arr[lo] hi -= 1 while arr[hi] > pivot: hi -= 1 if lo >= hi: break arr[lo] = arr[hi] if (lo == hi + 2): arr[lo] = arr[hi + 1] lo -= 1 arr[lo] = old_arr_hi if (pivot < old_arr_hi): lo -= 1 arr[pivot_ind], arr[lo] = arr[lo], arr[pivot_ind] return lo
We select our pivot as
arr[lo] this time, but it really doesn’t matter.
On the second line, we set the rightmost item to
pivot+1: our sentinel, which
we know is greater than the pivot. We know our leftmost item is less than or
equal to the pivot, since it is our pivot. Now in our main loop, we can
increment our indices without bounds checking! We do the minimal amount of
index checking to ensure our
hi indices don’t cross.
You may observe something peculiar in the main loop: there are no swaps! The
sentinel on the right side of the array is an element that did not exist in the
original array. We removed the element that was there initially. We call this
spot a vacancy. Now, in our main loop, as we increment our
lo index, and
once we reach an element greater than pivot, we can simply move it to the end
to fill the vacancy. The new vacany is at
lo. We similarly can fill that
vacancy after our
hi loop. In this partition scheme, the vacancy moves towards
the middle of the array. At the end of the procedure, there is some fix-up code
to re-insert the removed element in the right position.
We illustrate the vacancy with a lighter shade of red, while the other index is the normal shade:
This algorithm seems to do some messy clean-up at the end. This is ok: most of our time is spent in the main loop, so we want to optimize that. The clean-up only happens once per function call, so it’s negligible for large arrays.
Note that this algorithm is slightly different from the one presented during the talk. In the talk, the definition of partition allowed elements equal to the pivot to appear on both the left and right sides. Our requirements are more strict: we want equal elements only on the left side. Using this stricter definition allows us to generalize our algorithms to the more general partition which rearranges element based on a predicate as opposed to a pivot element. Though, for the Alexandrescu partition, the user would need to provide a sentinel value that would evaluate false with the predicate, as the algorithm cannot determine this for some arbitrary and unknown predicate.
We time how long it takes to partition arrays of various lengths. These arrays
are NumPy NDArrays filled with 32-bit integers sampled from a discrete uniform
distribution, where the minimum is 0 and maximum is
2*len(arr). We run these
algorithms 1000 times on random arrays for each array size. The timings were
measured in Python 3.8.5 on an Intel i5-8265U CPU @ 1.60GHz with 8gb of RAM on
A more thorough investigation would simulate a variety of data distributions to understand these algorithms’ behaviour, but in this post, we’re just interested in understanding the high level effects of some of the design decisions of these algorithms.
Nothing surprising here! All these algorithms take time proportional to the size of the arrays. We see that Alexandrescu’s is fastest across the board by a bit, followed by Hoare’s, then finally Lomuto’s. The bars represent a 95% confidence interval of the mean time, so our rankings are statistically significant (but perhaps not practically significant).
Number of Assignments
Recall that Lomuto’s algorithm did extra swaps compared to Hoare’s. We want to count and see if this is indeed the case on some random arrays. We will count the number of assignments into the array instead of swaps, since Alexandrescu’s partition does not do swaps.
In Python, swapping elements is as easy as
arr[lo], arr[hi] = arr[hi],
arr[lo], but under the hood, this is expanded to something like
arr[lo]; arr[lo] = arr[hi]; arr[hi] = tmp, which is a total of 3 assignments,
not 2. For the purposes of our measurements, we’ll only count assignments into
the array, that is, a swap will only be counted as 2 assignments.
The plot below shows the number of assignments into the array for random arrays of various sizes.
We can see that the Hoare and Alexandrescu lines overlap, giving evidence to our previous claim that both do the same number of swaps. Lomuto’s, as expected, does more swaps than the other two algorithms.
Number of Array Element Comparisons
Comparisons are needed to determine which side of the pivot a particular element should go.
All the lines are on top of eachother, indicating that they all do the same number of comparisons! This makes sense: all the algorithms compare each element to the pivot exactly once.
Well, this is a slight lie:
Alexandrescu’s and Hoare’s do a bit of extra comparing at the end as cleanup, while the elegant Lomuto’s partition does not.
Number of Array Index Comparisons
We saw the main innovation introduced by Alexandrescu’s partition is the sentinel which eliminated a lot of index checking. Let’s take a look at the number of index comparisons performed by these algorithms on random arrays.
As expected, Alexandrescu’s has the fewest by a landslide.
In the Python code, you can’t actually see the index comparisons for Lomuto’s
partition. But under the hood,
range needs to do these bounds checks. You can
see that more clearly if you rewrite the algorithm with a
def lomuto_partition(arr, lo, hi): pivot = arr[hi] j = lo while j < hi: if arr[j] <= pivot: arr[lo], arr[j] = arr[j], arr[lo] lo += 1 j += 1 arr[lo], arr[hi] = arr[hi], arr[lo] return lo
You would expect Hoare’s and Lomuto’s to match, since they do one index check per index increment/decrement. But actually, Hoare’s gets unchecked index changes after every swap.
We explored Lomuto’s, Hoare’s, and Alexandrescu’s partition schemes. While Lomuto’s is the simplest and most elegant, it does the most extra work. Hoare’s, for a bit more complexity, removes the extra swapping work. Alexandrescu’s uses a sentinel to avoid bounds checking. It also uses interesting half-swaps instead of full swaps, further saving work compared to a swap (due to not needing a temporary). With increasing complexity, we get improvements in efficiency, which we explained by counting the swaps, element comparisons, and index comparisons on random arrays.
Since the code is available, try things you think I missed! A good start would be animating or counting operations on data distributions other than uniformly random integers. For example, a common real world array distribution is a partially sorted array. Share what you find!
We have been doing our investigation in pure Python, which is pretty slow. Cython will convert your (statically typed) Python code to C, to avoid Python’s overhead. Here’s an example of this conversion for Lomuto’s in a Jupyter notebook cell:
%%cython -a cimport cython cimport numpy as np @cython.boundscheck(False) @cython.wraparound(False) def lomuto_partition_cython(np.ndarray[int, ndim=1] arr, int lo, int hi): cdef int pivot, j pivot = arr[hi] for j in range(lo, hi): if arr[j] <= pivot: arr[lo], arr[j] = arr[j], arr[lo] lo += 1 arr[lo], arr[hi] = arr[hi], arr[lo] return lo
By annotating the types of our parameters and pre-declaring our variables, we were able to convert this code to C. We can see that our function was successfully converted with minimal Python interaction (only at the function call and return). If there was Python interaction, this would slow down our code as we would have to leave C.
If we had not pre-declared our variables, for example, we would see some Python interaction, which is suboptimal:
Let’s compare the timings for the three algorithms after Cython compilation. Additionally, we can compare to NumPy’s built-in partition, since we’re now in the same order of magnitude of performance. Our experimental set-up is the same as before, but we do 10,000 runs instead of 1000 to get tighter confidence intervals.
Woah, our functions run almost 400x faster! Plus, based on our measurements, our Hoare’s partition implementation runs faster than the native NumPy implementation (which is written in C). We only beat NumPy here because our distribution is a uniformly random. NumPy uses an introspective algorithm: it monitors the progress of the algorithm and can switch partition schemes partway to ensure good average case performance and optimal worst case performance. This is crucial with real-world data distributions to ensure consistent performance, but adds some overhead.
I’m puzzled by why Alexandrescu’s partition ends up being the slowest of the bunch after Cython compilation, and would love to hear a Cython expert’s thoughts on this.