# Evens before Odds

One of my go-to interview questions goes like this:

Given an array of numbers, make it so the even numbers come before the odd ones.

For example, for { 1, 2, 3, 4, 5, 6, 7, 8 }, a possible output would be { 8, 2, 6, 4, 5, 3, 7, 1 }.

This is not a trick question by any means, it is a straightforward problem with
a couple of straightforward solutions. Note the *possible output* wording and
the fact that evens and odds in the output do not preserve the relative order
they had in the input.

## A Space-Inefficient Solution

An easy solution is to traverse the input once and store all even numbers encountered during the traversal into a separate array, then traverse it again and do the same for the odd numbers:

```
auto evens_before_odds(const std::vector<int>& numbers)
{
std::vector<int> result;
result.reserve(numbers.size());
for (int i : numbers)
if (i % 2 == 0)
result.push_back(i);
for (int i : numbers)
if (i % 2 != 0)
result.push_back(i);
return result;
}
```

This solves the problem in O(n) linear time (two traversals of the input array) and O(n) linear space - result is as large as input, so additional space required grows linearly with the size of the input.

There are more efficient way of doing this in linear time and constant space.

## Two Algorithms

There are a couple of ways we can solve this. One algorithm goes like this:

Find the first odd number. Stop if we reached the end of the array.

Find the first event number after that odd number. Stop if we reached the end of the array.

Swap them.

Repeat.

Our loop invariant is that all numbers before the first odd number (which we update during each iteration) are already in the right place. With each iteration, we find another even number that appears after the first odd number so we swap them, putting the even in the right place. We stop when we run out of numbers to swap, either odd or even. An implementation of this algorithm looks like this:

```
void evens_before_odds(std::vector<int>& numbers)
{
int i = 0, j, n = numbers.size();
for (;;)
{
// Find first odd number
while (i != n && numbers[i] % 2 == 0)
++i;
// If we reached the end we're done
if (i == n)
return;
// Find the first even number after the first odd one
j = i + 1;
while (j != n && numbers[j] % 2 != 0)
++j;
// If we reached the end we're done
if (j == n)
return;
// Swap and continue
std::swap(numbers[i], numbers[j]);
++i;
}
}
```

While the algorithm is fairly straight-forward, the devil is in the details - we need to perform multiple checks to make sure we don’t run off the end of the array. While interviewing, I’ve seen many bugs come up due to missing some of these checks.

An interesting observation we can make is that once we found the first pair of odd and even numbers, after we swap them, the new first odd number is right after the even we just swapped, so we can hoist the first while statement out of the main loop - we only need to find the first odd once, then we just increment after each swap:

```
void evens_before_odds(std::vector<int>& numbers)
{
int i = 0, j, n = numbers.size();
// Find the first odd number
while (i != n && numbers[i] % 2 == 0)
++i;
// If we reached the end we’re done
if (i == n)
return;
// Start after the first odd and until we reach the end
for (int j = i + 1; j != n; ++j)
{
// If it’s an even number
if (numbers[j] % 2 == 0)
{
// Swap with the first odd
std::swap(numbers[i], numbers[j]);
// Increment first odd position
++i;
}
}
}
```

Another algorithm goes like this:

Find the first odd number.

From the back, find the last even number.

Stop if the first odd number appears after the last even number.

Swap and repeat.

Our loop invariant is that all numbers before the first odd and all numbers after the last even are already in place. With each iteration, we move the first odd and last even. We stop when the first odd appears after the last even, which means all evens appear before the odds. Here is a possible implementation:

```
void evens_before_odds(std::vector<int>& numbers)
{
int i = 0, j = numbers.size();
for (;;)
{
// Find the first odd number
while (i != j && numbers[i] % 2 == 0)
++i;
// If the first odd occurs after the last even, stop
if (i == j)
return;
// Find the last even number
--j;
while (i != j && numbers[j] % 2 != 0)
--j;
// If the first odd occurs after the last even, stop
if (i == j)
return;
// Swap and continue
std::swap(numbers[i], numbers[j]);
++i;
}
}
```

Both of the above algorithms solve the problem in linear time and constant space.

### Test Cases

Some interesting test cases to validate the implementations:

- Our example input {1, 2, 3, 4, 5, 6, 7, 8 }
- An empty vector { }
- A vector with a single even number { 2 }
- A vector with a single odd number { 1 }
- A vector consisting of all even number { 2, 4, 6 }
- A vector consisting of all odd numbers { 1, 3, 5 }

### Follow Up: Odds before Evens

My follow up question is

What if we also want the ability to put odd numbers before even ones? How would we extend our code?

An answer I’m **not** looking for is *we copy/paste the function, rename it to*
odds_before_evens *and update the checks*.

A clever answer (which I’m also not looking for) is *we provide an*
odds_before_evens *which internally calls* evens_before_odds *, then
reverses the output*:

```
void odds_before_evens(std::vector<int>& numbers)
{
evens_before_odds(numbers);
std::reverse(numbers.begin(), numbers.end());
}
```

A common answer is *we add a flag*:

```
void arrange_numbers(std::vector<int>& numbers, bool evensFirst)
{
int i = 0, j = numbers.size();
for (;;)
{
while (i != j && ((evensFirst && numbers[i] % 2 == 0)
|| (!evensFirst && numbers[i] %2 != 0)))
++i;
if (i == j)
return;
--j;
while (i != j && ((evensFirst && numbers[j] % 2 != 0)
|| (!evensFirst && numbers[j] % 2 == 0)))
--j;
if (i == j)
return;
std::swap(numbers[i], numbers[j]);
++i;
}
}
```

This kind of works, but the condition becomes very complicated.

### Follow Up: Primes before Non-Primes

What if we also want to move prime numbers before non-prime numbers, given some bool is_prime(int) primality-testing function?

We can keep adding flags and extending the if conditions:

```
enum class Arrangement
{
EvensBeforeOdds,
OddsBeforeEvens,
PrimesBeforeNonPrimes,
};
void arrange_numbers(std::vector<int>& numbers, Arrangement arrangement)
{
int i = 0, j = numbers.size();
for (;;)
{
while (i != j && ((arrangement == Arrangement::EvensBeforeOdds && numbers[i] % 2 == 0)
|| (arrangement == Arrangement::OddsBeforeEvens && numbers[i] %2 != 0)
|| (arrangement == Arrangement::PrimesBeforeNonPrimes && is_prime(numbers[i]))))
++i;
if (i == j)
return;
--j;
while (i != j && ((arrangement == Arrangement::EvensBeforeOdds && numbers[j] % 2 != 0)
|| (arrangement == Arrangement::OddsBeforeEvens && numbers[j] % 2 == 0)
|| (arrangement == Arrangement::PrimesBeforeNonPrimes && !is_prime(numbers[j]))))
--j;
if (i == j)
return;
std::swap(numbers[i], numbers[j]);
++i;
}
}
```

This doesn’t scale very well though. What we actually want to do here is abstract away the predicate based on which we move elements around:

```
template <typename Pred>
void arrange_numbers(std::vector<int>& numbers, Pred pred)
{
int i = 0, j = numbers.size();
for (;;)
{
while (i != j && pred(numbers[i]))
++i;
if (i == j)
return;
--j;
while (i != j && !pred(numbers[j]))
--j;
if (i == j)
return;
std::swap(numbers[i], numbers[j]);
++i;
}
}
void evens_before_odds(std::vector<int>& numbers)
{
arrange_numbers(numbers, [](int i) { return i % 2 == 0; });
}
void odds_before_evens(std::vector<int>& numbers)
{
arrange_numbers(numbers, [](int i) { return i % 2 != 0; });
}
void primes_before_non_primes(std::vector<int>& numbers)
{
arrange_numbers(numbers, is_prime);
}
```

Note the algorithm remains the same: we have the exact same steps and loop invariants, but we can parameterize the condition. With this abstraction, the code actually becomes smaller and more readable.

This is about as far as I can get during an interview.

## Partition

This is actually a well-known algorithm called a *partitioning algorithm*. A
partitioning algorithm moves elements that satisfy a predicate before elements
that don’t satisfy it. Let’s start with the above implementation:

```
template <typename Pred>
void partition(std::vector<int>& numbers, Pred pred)
{
int i = 0, j = numbers.size();
for (;;)
{
while (i != j && pred(numbers[i]))
++i;
if (i == j)
return;
--j;
while (i != j && !pred(numbers[j]))
--j;
if (i == j)
return;
std::swap(numbers[i], numbers[j]);
++i;
}
}
```

This works for vectors, but what if we want to partition a doubly-linked list?
Can we abstract away the data structure we are partitioning? The answer is
*yes*. We can use iterators to access the data structure:

```
template <typename It, typename Pred>
void partition(It first, It last, Pred pred)
{
for (;;)
{
while (first != last && pred(*first))
++first;
if (first == last)
return;
--last;
while (first != last && !pred(*last))
--last;
if (first == last)
return;
std::swap(*first, *last);
++first;
}
}
```

The implementation is virtually the same. We get rid of i and j, as we are using the iterators provided as arguments for traversal. The implementation does not increase in complexity, but is now usable beyond vectors. For example we can now partition a C-style array:

```
void evens_before_odds(int arr[], int n)
{
partition(arr, arr + n, [](int i) { return i % 2 == 0; });
}
```

### Useful Return

A useful return for our algorithm is the *partition point* - the position of the
first element that does not satisfy our predicate. We have this implicitly and
callers might be interested in it. To avoid making callers have to recompute it,
we should return it:

```
template <typename It, typename Pred>
auto partition(It first, It last, Pred pred)
{
for (;;)
{
while (first != last && pred(*first))
++first;
if (first == last)
return first;
--last;
while (first != last && !pred(*last))
--last;
if (first == last)
return first;
std::swap(*first, *last);
++first;
}
}
```

For example, partition is a key ingredient in quicksort:

```
template <typename It, typename Comp>
void quick_sort(It first, It last, Comp comp)
{
// Stop if we have no elements or one element
auto dist = std::distance(first, last);
if (dist < 2) return;
// Swap pivot with last element
auto pivot = first + dist / 2;
std::iter_swap(pivot, --last);
// Partition around pivot
auto p = partition(first, last, [&](auto&& i) {
return comp(i, *last);
});
// Move pivot back in place
std::iter_swap(p, last);
// Recursively sort left and right sides of the pivot
quick_sort(first, p, comp);
quick_sort(p + 1, ++last, comp);
}
```

### STL Implementations

The partition algorithm we ended up with is fairly efficient, but it’s worth taking a look at some of the highly-optimized STL implementations. This is the MSVC STL implementation:

```
template <typename It, typename Pred>
auto partition(It first, It last, Pred pred)
{
for (;; ++first)
{
for (; first != last && pred(*first); ++first);
if (first == last) break;
for (; first != --last && !pred(*last););
if (first == last) break;
iter_swap(first, last);
}
return first;
}
```

Note this performs the least possible amount of operations. It also seems to favor for loops. Contrast this with the LLVM libc++ implementation, which seems to favor while loops:

```
template <typename It, typename Pred>
auto partition(It first, It last, Pred pred)
{
while (true)
{
while (true)
{
if (first == last) return first;
if (!pred(*first)) break;
++first;
}
do
{
if (first == --last) return first;
} while (!pred(*last));
swap(*first, *last);
++first;
}
}
```

### Iterator Requirements and Complexity

We focused on the second algorithm presented, which finds the first odd, last
even, and swaps them. We had another algorithm which was looking for *the first
even after the first odd* during each iteration. Let’s provide a generic
implementation for it too:

```
template <typename It, typename Pred>
auto partition(It first, It last, Pred pred)
{
while (first != last && pred(*first))
++first;
if (first == last)
return first;
for (It next = std::next(first); next != last; ++next)
if (pred(*next))
{
std::swap(*first, *next);
++first;
}
return first;
}
```

What is the difference?

The difference is that this algorithm only ever increments the iterators. That
means it only requires a ForwardIterator, as opposed to the other algorithm,
which finds the *last even* number starting from the last iterator, which
requires a BidirectionalIterator.

In other words, the algorithm requiring only a ForwardIterator works on a singly-linked list (forward_list), while the other one can’t (we can only traverse a singly-linked list forward in O(1) time, not backwards).

The MSVC STL implementation of the forward-iterator algorithm is:

```
template<typename It, typename Pred>
auto partition(It first, It last, Pred pred)
{
while (first != last && pred(*first))
++first;
if (first == last)
return first;
for (It next = next(first); next != last; ++next)
if (pred(*next))
iter_swap(first++, next);
return first;
}
```

The libc++ one is:

```
template <typename It, tpyename Pred>
auto partition(It first, It last, Pred pred)
{
while (true)
{
if (first == last)
return first;
if (!pred(*first))
break;
++first;
}
for (It next = first; ++next != last;)
{
if (pred(*next))
{
swap(*first, *next);
++first;
}
}
return first;
}
```

The reason both implementations are provided is that the ForwardIterator version, while more generally applicable, is slightly less efficient. The BidirectionalIterator version moves any element at most once, and since the move is a swap, it means it performs at most N / 2 swaps where N is the number of elements. The ForwardIterator version might perform more swaps, up to N. For example, for the input 1 2 4, during the first step, it would swap 1 with 2, ending up with 2 1 4, then during the next step it would swap 1 with 4, ending up with 2 4 1.

## In C#

Partitioning is not specific to the C++ language. The same implementation can be used, for example, in C#, up to abstracting away data structure traversal:

```
public static class IListPartition
{
public static int Partition<T>(this IList<T> self, Func<T, bool> pred)
{
int first = 0, last = self.Count;
for (;;)
{
while (first != last && pred(self[first]))
++first;
if (first == last)
return first;
--last;
while (first != last && !pred(self[last]))
--last;
if (first == last)
return first;
var temp = self[first];
self[first] = self[last];
self[last] = temp;
++first;
}
}
}
```

The .NET IEnumerator does not allow us to mutate the data structure we are enumerating over, so we cannot provide a generic IEnumerable<T> partition algorithm that works in-place. Otherwise the implementation is pretty much identical to the C++ one, as the algorithm is the same.

## Summary

- Moving even numbers before odd ones in a given array of numbers is an instance of partition.
- The algorithm can be generalized to work with an arbitrary predicate.
- The algorithm can be generalized to work across any data structure as long as it can be traversed with at least a ForwardIterator.
- A BidirectionalIterator version performs at most N / 2 swaps (and N applications of the predicate).
- A ForwardIterator version performs at most N swaps (and N applications of the predicate).
- Both versions of the algorithm are part of the standard library (std::partition algorithm).
- The same algorithm can be implemented in other languages, as generic as the available abstractions allow.