Asymptotic complexity of std::remove_if

Question

I am working on an erase method for a data structure with a hard-coded maximum number of elements, N, that relies on std::array to avoid heap memory. Although the std::array contains N elements only some number, M, of them are "relevant" elements where M is less than or equal to N. As an example, if N is 10 and the array looks like this:

std::array<int, N> elements = { 0, 1, 2, -1, 4, -1, 6, -1, -1, 9 };

...and if M is 7, only the first 7 elements are "relevant" while the others are considered junk (the ending { -1, -1, -9 } are junk). I am using int here for a SO example but the real program stores objects that implement operator==. Below is a working example that removes all -1 and updates M:

#include <algorithm>
#include <array>
#include <iostream>

constexpr unsigned N = 10;
unsigned           M = 7;
std::array<int, N> elements = { 0, 1, 2, -1, 4, -1, 6, -1, -1, 9 };

int main() {
        for (unsigned i = 0; i < M; ++i)
                std::cout << elements[i] << ' ';
        std::cout << '\n';

        auto newEnd = std::remove_if(
                std::begin(elements), std::begin(elements) + M,
                [](const auto& element) {
                        return -1 == element;
                }
        );

        unsigned numDeleted = M - std::distance(std::begin(elements), newEnd);
        M -= numDeleted;
        std::cout << "Num deleted: " << numDeleted << '\n';

        for (unsigned i = 0; i < M; ++i)
                std::cout << elements[i] << ' ';
        std::cout << '\n';

        return 0;
}

The question I have is what is the asymptotic complexity of the std::remove_if? I would imagine that between the std::remove_if and std::distance it is overall O(2M) or O(M) where the std::remove_if is a more expensive operation. However I am not sure if the std::remove_if is O(N * M) due to shifting elements per deletion

Edit: For clarity, I understand that this should be applying the predicate M times but am wondering if N shifts are being applied each time the predicate is true

Answer 1

By cppreference:

Complexity: Exactly std::distance(first, last) applications of the predicate.

There are no shift operations on the removed elements because they can have unspecified value after the call to std::remove_if

Answer 2

Edit

This answer, in retrospect, addresses a more complicated question than what was asked - how could a "push back to end" function be implemented in linear time. Regarding the specific question asked - pertaining to remove_if - @millenimumbug's answer addresses it better.

---

I can see why you'd think that the complexity would be Θ(m n), as each of the m removed items might need to be shifted Θ(n) distance.

It is actually possible to do this in time Θ(n) and additional O(1) space (just a few additional iterators).

Consider the following diagram, showing an iteration of a possible implementation of the algorithm.

The red items are a contiguous group of recognized items to be removed to the end, at this point (you just need two points to record this). The green item is the item now being considered (another pointer).

If the green item is to be removed, the red group simply becomes bigger by including it. This is shown in the next diagram, where the red group expands. In the next iteration, the green item will be the one to the right of it.

If not, all the red group needs to be shifted past it. Some thought can convince you that this can be done in linear time in the red group (even though the iterators are guaranteed to be only forward iterators).

Why is the complexity linear? Because you can imagine this as being equivalent to the green element being shifted left relative to the left group. The rationale is similar to that of amortized analysis.

The following diagram shows the second case. In the next iteration, the green element (being considered) will again be to the right of the red group.