Question

We have large (100,000+ elements) ordered vectors of structs (operator < overloaded to provide ordering):

std::vector < MyType > vectorMyTypes;
std::sort(vectorMyType.begin(), vectorMyType.end());

My problem is that we’re seeing performance problems when adding new elements to these vectors while preserving sort order. At the moment we’re doing something like:

for ( a very large set )
{
    vectorMyTypes.push_back(newType);
    std::sort(vectorMyType.begin(), vectorMyType.end());

    ...

    ValidateStuff(vectorMyType); // this method expects the vector to be ordered
}

This isn’t exactly what our code looks like since I know this example could be optimised in different ways, however it gives you an idea of how performance could be a problem because I’m sorting after every push_back.

I think I essentially have two options to improve performance:

1. Use a (hand crafted?) insertion sort instead of std::sort to improve the sort performance (insertion sorts on a partially sorted vector are blindingly quick)

2. Create a heap by using std::make_heap and std::push_heap to maintain the sort order

My questions are:

• Should I implement an insertion sort? Is there something in Boost that could help me here?

• Should I consider using a heap? How would I do this?

---

Edit:

Thanks for all your responses. I understand that the example I gave was far from optimal and it doesn’t fully represent what I have in my code right now. It was simply there to illustrate the performance bottleneck I was experiencing – perhaps that’s why this question isn’t seeing many up-votes 🙂

Many thanks to you Steve, it’s often the simplest answers that are the best, and perhaps it was my over analysis of the problem that blinded me to perhaps the most obvious solution. I do like the neat method you outlined to insert directly into a pre-ordered vector.

As I’ve commented, I’m constrained to using vectors right now, so std::set, std::map, etc aren’t an option.

Answer 1

Ordered insertion doesn’t need boost:

vectorMyTypes.insert(
    std::upper_bound(vectorMyTypes.begin(), vectorMyTypes.end(), newType),
    newType);

upper_bound provides a valid insertion point provided that the vector is sorted to start with, so as long as you only ever insert elements in their correct place, you’re done. I originally said lower_bound, but if the vector contains multiple equal elements, then upper_bound selects the insertion point which requires less work.

This does have to copy O(n) elements, but you say insertion sort is “blindingly fast”, and this is faster. If it’s not fast enough, you have to find a way to add items in batches and validate at the end, or else give up on contiguous storage and switch to a container which maintains order, such as set or multiset.

A heap does not maintain order in the underlying container, but is good for a priority queue or similar, because it makes removal of the maximum element fast. You say you want to maintain the vector in order, but if you never actually iterate over the whole collection in order then you might not need it to be fully ordered, and that’s when a heap is useful.