为查找优化的哈希映射

Question

I am looking for some map which has fixed keys (fixed during initialization) and that does faster look-up. It may not support adding/updating elements later. Is there some algorithm which looks the list of keys and formulates a function so that it is faster to look-up later. In my case, keys are strings.

Update:

Keys are not known at compile time. But during initialization time of the application. There wont be any further insertions later but there will be lots of look-ups. So I want look-ups to be optimized.

Answer 1

CMPH may be what you're looking for. Basically this is gperf without requiring the set at compile-time.

Though of course std::unordered_map as by C++11 might just do too, though possibly with a few collisions.

Since you lookup strings, for strings, a trie (any of the different trie flavours, crit-bit or whatever funky names they have) may also be worthwhile to look into, especially if you have many of them. There are a lot of free trie implementations freely available.
The advantage of tries is that they can index-compress strings, so they use less memory, which has a higher likelihood of having data in cache. Also the access pattern is less random, which is also cache-friendly. A hash table must store the value plus the hash, and indexes more or less randomly (not randomly , but unpredictably) into memory. A trie/trie-like structure ideally only needs one extra bit that distinguishes a key from its common prefix in each node.

(Note by the way that O(log(N)) may quite possibly be faster than O(1) in such a case, because big-O does not consider things like that.)

Answer 2

Note that these are distinct things: do you need an upper limit, do you need a fast typical rate, or do you need the fastest lookup ever, no questions asked? The last one will cost you, the first two ones may be conflicting goals.

---

You could attempt to create a perfect hash function based on the input (ie one that does not have collisions of the input set). This is a somehow-solved problem (eg this , this ). However, they usually generate source code and may spend significant time generating the hash function.

A modification of this would be using a generic hash function (eg shift-multiply-add) and do a brute force search over suitable parameters.

This has to be traded off with the cost of a few string comparisons (which aren't that terribly expensive if you don't have to collate).

Another option is to use two distinct hash functions - this increases the cost of a single lookup but makes degradation slightly less likely than aliens stealing your clock cylces. It is rather unlikely that this would be a problem with typical strings and a decent hash function.

Answer 3

Try google-sparsehash: http://code.google.com/p/google-sparsehash/

An extremely memory-efficient hash_map implementation. 2 bits/entry overhead! 
The SparseHash library contains several hash-map implementations, including 
implementations that optimize for space or speed.

Answer 4

In a similar topic ((number of) items known at compile time) , I produced this one: Lookups on known set of integer keys . Low overhead, no need for perfect hash. Fortunately, it is in C ;-)