优化循环C ++

Question

I have this small function that loops through a vector to find a given animal and return its habitat. I need to optimize it, but I'm hitting dead ends with what I could be doing. Three things that popped out at me was size_t , i++ , and the fact I'm looping through a vector. I read that size_t is great for arrays that have a large size index. I know that pre-increment is better than post-increment since it changes the original value instead of creating a temp and incrementing. But compilers usually optimize this small difference anyway. Finally, the last thing I thought was that this vector could be unsorted, therefore dipping in performance. I was thinking of sorting the vector by the species variable of animals, then maybe porting it into a BST to search since the time complexity would be O(log(n)) . Here is the code I'm working with:

string GetAnimalHabitat(vector<Animal> animals, string species)
{
    for (size_t i = 0; i < animals.size(); i++)
    {
        if (animals[i].species == species)

        {
            return animals[i].habitat;
        }
    }
    return "Animal not within records.";
}

Is there anything that I'm potentially missing that could improve this function? Any tips would be great. Thanks!

Answer 1

A std::map surely works better than looping over a vector here:

string GetAnimalHabitat(const map<string, string>& animals, const string& species)
{
    auto search = animals.find(species);
    if (search != animals.end())
        return search->second;
    return string("Animal not within records.");
}

It requires building a map first, however. But building it once is enough and you only have to add new key pairs to it:

map<string, string> build_map(const vector<Animal>& animals)
{
    map<string, string> ret;
    for (const auto& x : animals)
        ret[x.species] = x.habitat;
    return ret;
}

Answer 2

One thing you could do is reduce the number of times .size() method gets called, by doing something like this:

size_t vectorSize = animals.size();
for (size_t i = 0; i < vectorSize; i++)
{
    if (animals[i].species == species)

    {
        return animals[i].habitat;
    }
}

Another minor one would be to change i++ to ++i . The purpose of this is to avoid storing the value of i in a register every time it increments.

Answer 3

At a high level, you want to stop making a full copy of the vector and all its elements each time you call this function. If you're needing to optimize, I assume the vector is large, so why not pass a reference to a const vector?

Second, another problem is how many elements of the vector will match your input string? If it's just a few, then scanning the whole vector is loading a lot of memory just to look at it to decide you don't need it. Since you return after the first match, it's reasonable to think there is at most one of each species, and in that case an associative container is better.

Some latency sensitive places partition data into different groups so no "filtering" is necessary. Just look at the group of things you care about and only process those.

Another thing to consider, a string comparison is much slower than something like an integer comparison. You could pre-hash the species into the class, hash the species parameter before your loop, and compare the hashes. If they are equal, THEN compare the strings to make sure it's a real match.

But my guess is most of your time is spent copying your inputs and outputs.

Answer 4

std::unordered_map makes the most sense since order is not important

string GetAnimalHabitat(const std::unordered_map<string, string>& animals, const string& species)
{
    auto search = animals.find(species);
    if (search != animals.end())
        return search->second;
    return string("Animal not within records.");
}

It requires building a map first, however. But building it once is enough and you only have to add new key pairs to it. Note that first time you pass a empty unordered_map in, after that you pass a vector of new values and the current map:

build_map(const std::vector<Animal>& animals, std::unordered_map<string_string> * ret)
{
    for (const auto& x : animals)
        ret[x.species] = x.habitat;
}