c++ hash_map/unordered_map 使用

C＋＋中有很多中key-value形式的容器，map／hash_map／unordered_map／vector_map。下面讲述各个map的使用及其区别。

map:

#include <iostream>
#include <map>
using namespace std;
 
typedef std::map<int, string> Map;
typedef Map::iterator MapIt;
 
int main()
{
    Map *map = new Map();
    int key;
    string value;
    while(cin>>key>>value)
    {
        map->insert(make_pair(key, value));
    }
    for(MapIt it = map->begin(); it != map->end(); ++it)
        cout<<"key:"<<it->first<<" value:"<<it->second<<endl;
    delete map;
    return 0;
}

map使用红黑树实现。查找时间在O(lg(n))-O(2*log(n))之间，构建map花费的时间比较长，因而，map使用于那种插入和查询混合的情况。如果是先插入后查询的情况，可以考虑使用vector_map.

 

vector_map在C＋＋中没有实现，想使用可以自己实现。其基本思想在于使用vector来保存数据，插入完成后进行排序，然后使用而分查找进行查询。这样在先插入后查询的条件下，性能会比map好很多。原因主要在一下几个方面。

1. vector使用线性存储，map是二叉树形状，所以vector的局部性更好。
2. vector可以一次分配很大的内存，而map需要每次分配一个节点，而且map中相对于vector有很多冗余数据，比如指向子节点的指针。
3. vector是插入完成后统一进行排序，而map每次insert都有一次查找和树的旋转。
4. vector_map是二分查找，查找时间稳定在O(lg(n))，而map的存储结构是红黑树，查找时间为O(lg(n))-O(2*log(n))。

 

map的key可以是自定义数据结构，

但是需要重载<运算符。如下代码所示：

typedef struct _Key
{
    _Key(int *p, int l)
    {
        len_ = l;
        for(int i = 0; i < l; ++i)
            p_[i] = p[i];
    }
    bool operator<(const _Key &rs) const
    {
        if(len_ == rs.len_)
        {
            for(int i = 0; i < len_; ++i)
                return p_[i] < rs.p_[i];
            return false;
        }
        else
            return len_ < rs.len_;
    }
    int p_[MaxLen];
    int len_;
}Key;
typedef std::map<Key, vector<int> *> MyMap;

需要注意的是，重载函数必须为const的。

当然，你也可以这么做：

typedef struct _Key
{
    _Key(int *p, int l)
    {
        len_ = l;
        for(int i = 0; i < l; ++i)
            p_[i] = p[i];
    }
    int p_[MaxLen];
    int len_;
}Key;
typedef struct _KeyCmp
{
    bool operator()(const Key &ls, const Key &rs)
    {
        if(ls.len_ == rs.len_)
        {
            for(int i = 0; i < ls.len_; ++i)
                return ls.p_[i] < rs.p_[i];
            return false;
        }
        else
            return ls.len_ < rs.len_;
    }
}KeyCmp;
typedef std::map<Key, vector<int> *, KeyCmp> MyMap;

与上面有相同的效果。

hash_map

hash_map，STL中的实现叫做unordered_map，都是基于hash_table实现的。首先，分配一大片内存，形成很多桶。利用hash函数，将key映射到不同的桶中，当然，也有可能会有两个不同的key映射到同一个桶中，这是，就需要判别函数来进行查找了。所以，hash_map的key需要两个条件，一个是hash函数，获得映射到的桶的值，另外一个是equal_to函数，判定两个key是否相等。显然，当每个桶里的元素个数比较平均且比较少的时候，查询性能比较高。

使用样例如下：

#include <string>
#include <iostream>
#include <ext/hash_map>
using namespace std;
using namespace __gnu_cxx;
 
struct str_hash
{
    size_t operator()(const string &s) const
    {
        return __stl_hash_string(s.c_str());
    }
};
 
struct str_compare
{
    int operator()(const string &a, const string &b) const
    {
        return (a==b);
    }
};
typedef hash_map<string, string, str_hash, str_compare> StrMap;
 
int main()
{
    StrMap strMap;
    string a,b;
    cout<<"插入:"<<endl;
    while(cin>>a>>b)
    {
        if(a.length() <= 1)
            break;
        strMap.insert(make_pair(a,b));
    }
    cout<<"查询:"<<endl;
    while(cin>>a)
    {
        if(a.length() <= 1)
            break;
        if(strMap.find(a) != strMap.end())
            cout<<strMap[a]<<endl;
        else
            cout<<"not found"<<endl;
    }
    return 0;
}

 

unordered_map

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;
 
unsigned int JSHash(const char *str)
{
    unsigned int hash = 1315423911;
    while(*str)
    {
        hash ^= ((hash<< 5) + (*str++) + (hash>>2));
    }
    return (hash & 0x7FFFFFFF);
}
 
struct StrHash
{
    size_t operator()(const string &s) const
    {
        return JSHash(s.c_str());
    }
};
struct StrCompare
{
    bool operator()(const string &a, const string &b) const
    {
        return a==b;
    }
};
typedef unordered_map<string, string, StrHash, StrCompare> MyMap;
int main()
{
    MyMap mymap;
    string a,b;
    while(cin>>a>>b)
    {
        mymap[a] = b;
    }
    for(MyMap::iterator it = mymap.begin(); it != mymap.end(); ++it)
        cout<<it->first<<" "<<it->second<<endl;
    return 0;
}

 

总体来说，hash_map的查找速度比map要快，因为hash_map的查找速度与数据量大小无关，属于常数级别。map的查找速度是log(n)级别。但是hash_map每次查找都需要执行hash函数，所以也比较耗时。而且，hash_map很多桶中可能都没有元素，所以内存利用率不高。