Fast search algorithm with std::vector

Question

    for (std::vector<const std::string>::const_iterator it = serverList.begin(); it != serverList.end(); it++)
    {
        // found a match, store the location
        if (index == *it) // index is a string
        {
            indexResult.push_back(std::distance(serverList.begin(), it)); // std::vector<unsigned int>
        }
    }

I Have written the above code to look through a vector of strings and return another vector with the location of any "hits".

Is there a way to do the same, but faster? (If I have 10,000 items in the container, it will take a while). Please note that I have to check ALL of the items for matches and store its position in the container.

Bonus Kudos: Anyone know any way/links on how I can make the search so that it finds partial results (Example: search for "coolro" and store the location of variable "coolroomhere")

Instead of `i`, say `std::distance(serverList.begin(), it)`; or just access the vector by index. — Kerrek SB, Nov 14 '11 at 13:48

score 9 · Answer 1 · answered Nov 14 '11 at 13:47

9

Use binary_search after sorting the vector

std::sort( serverList.begin() , serverList.end() )
std::lower_bound(serverList.begin() , serverList.end() , valuetoFind) to find first matching
Use std::equal_range if you want to find all matching elements

The lower_bound & equal_range search because it is binary is logarithmic compared to your search that is O(N)

answered Nov 14 '11 at 13:47

parapura rajkumar

24,045
1
55
85

If the data structure itself is amenable to redesign, an `unordered_multiset` might even be more appropriate. – Kerrek SB Nov 14 '11 at 14:09
My inclination on things I will want sorted is to just add them in sorted in the first place. – T.E.D. Nov 14 '11 at 14:12
Of course this will only pay if he needs to do it more often, as it is O(nlogn) and his current approach is only O(n). – Christian Rau Nov 14 '11 at 14:25
@ChristianRau - ...or if you are inclined to trade startup time for runtime. – T.E.D. Nov 14 '11 at 15:27

score 7 · Accepted Answer · edited Apr 04 '20 at 06:06

Basically, you're asking if it's possible to check all elements for a match, without checking all elements. If there is some sort of external meta-information (e.g. the data is sorted), it might be possible (e.g. using binary search). Otherwise, by its very nature, to check all elements, you have to check all elements.

If you're going to do many such searches on the list and the list doesn't vary, you might consider calculating a second table with a good hash code of the entries; again depending on the type of data being looked up, it could be more efficient to calculate the hash code of the index, and compare hash codes first, only comparing the strings if the hash codes were equal. Whether this is an improvement or not largely depends on the size of the table and the type of data in it. You might also, be able to leverage off knowledge about the data in the strings; if they are all URL's, for example, mostly starting with "http://www.", starting the comparison at the tenth character, and only coming back to compare the first 10 if all of the rest are equal, could end up with a big win.

With regards to finding substrings, you can use std::search for each element:

for ( auto iter = serverList.begin();
        iter != serverList.end();
        ++ iter ) {
    if ( std::search( iter->begin(), iter->end(),
                      index.begin(), index.end() ) != iter->end() ) {
        indexResult.push_back( iter - serverList.begin() );
    }
}

Depending on the number of elements being searched and the lengths of the strings involved, it might be more efficient to use something like BM search, however, precompiling the search string to the necessary tables before entering the loop.

T.E.D. · Answer 3 · 2011-11-14T14:35:44.627

2

If you make the container a std::map instead of a std::vector, the underlying data structure used will be one that is optimized for doing keyword searches like this.

If you instead use a std::multimap, the member function equal_range() will return a pair of iterators covering every match in the map. That sounds to me like what you want.

A smart commenter below points out that if you don't actually store any more infomation than the name (the search key), then you should probably instead use a std::multiset.

edited Nov 14 '11 at 14:35

answered Nov 14 '11 at 14:13

T.E.D.

44,016
10
73
134

1

Since he doesn't store anything else in there, a `std::multiset` would even be better. – Christian Rau Nov 14 '11 at 14:23

Fast search algorithm with std::vector

3 Answers3