map与unordered_map

头文件

map: #include < map >
unordered_map: #include < unordered_map >

内部实现机理
map： map内部实现了一个红黑树，该结构具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素，因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行这样的操作，故红黑树的效率决定了map的效率。
unordered_map: unordered_map内部实现了一个哈希表，因此其元素的排列顺序是杂乱的，无序的

优缺点以及适用处
map
优点： 有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作，内部实现一个红黑书使得map的很多操作在lgn的时间复杂度下就可以实现，因此效率非常的高
缺点：
空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点，孩子节点以及红/黑性质，使得每一个节点都占用大量的空间
适用处，对于那些有顺序要求的问题，用map会更高效一些

unordered_map
优点：
因为内部实现了哈希表，因此其查找速度非常的快
缺点：
哈希表的建立比较耗费时间
适用处，对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用unordered_map

note:
对于unordered_map或者unordered_set容器，其遍历顺序与创建该容器时输入元素的顺序是不一定一致的，遍历是按照哈希表从前往后依次遍历的

》》》》》》》》》》》》》》》》》》

unordered_map和map类似，都是存储的key-value的值，可以通过key快速索引到value。不同的是unordered_map不会根据key的大小进行排序，

unordered_map存储时是根据key的hash值判断元素是否相同，即unordered_map内部元素是无序的，
map中的元素是按照二叉搜索树存储，进行中序遍历会得到有序遍历。

所以使用时map的key需要定义operator<。而unordered_map的key需要定义hash_value函数并且重载operator==。但是很多系统内置的数据类型都自带这些，

那么如果是自定义类型，那么就需要自己重载operator<或者hash_value()了。

结论：如果需要内部元素自动排序，使用map，不需要排序使用unordered_map

其实，stl::map对于与Java中的TreeMap，而boost::unordered_map对应于java中的HashMap。

stl::map

#include<string>  
#include<iostream>  
#include<map>  

using namespace std;  

struct person  
{  
    string name;  
    int age;  

    person(string name, int age)  
    {  
        this->name =  name;  
        this->age = age;  
    }  

    bool operator < (const person& p) const  
    {  
        return this->age < p.age;  //这里比较age，map用的时候只要age一样就认为相等，则不插入
    }  
};  

map<person,int> m;  
int main()  
{  
    person p1("Tom1",20);  
    person p2("Tom2",22);  
    person p3("Tom3",22);  
    person p4("Tom4",23);  
    person p5("Tom5",24);  
    m.insert(make_pair(p3, 100));  
    m.insert(make_pair(p4, 100));  
    m.insert(make_pair(p5, 100));  
    m.insert(make_pair(p1, 100));  
    m.insert(make_pair(p2, 100));  

    for(map<person, int>::iterator iter = m.begin(); iter != m.end(); iter++)  
    {  
        cout<<iter->first.name<<"\t"<<iter->first.age<<endl;  
    }  

    return 0;  
}  

output:

Tom1    20
Tom3    22
Tom4    23
Tom5    24

因为Tom2和Tom3的age相同，由我们定义的operator<只是比较的age，所以Tom3覆盖了Tom2，结果中没有Tom2。
如果运算符<的重载是如下

bool operator < (const person &p)const
{
    return this->name < p.name;  
}

输出结果： 按照 那么进行的排序，如果有那么相同则原来的那么会被覆盖

Tom1    20
Tom2    22
Tom3    22
Tom4    23
Tom5    24

operator<的重载一定要定义成const。因为map内部实现时调用operator<的函数好像是const。
由于operator<比较的只是age,所以因为Tom2和Tom3的age相同，所以最终结果里面只有Tom3，没有Tom2

2、
unordered_map

#include<string>  
#include<iostream>  

#include<map>  
#include<unordered_map>
//#include<boost/unordered_map.hpp>  
using namespace std;  

struct person  
{  
    string name;  
    int age;  

    person(string name, int age)  
    {  
        this->name =  name;  
        this->age = age;  
    }  

    bool operator== (const person& p) const  
    {  
        return name==p.name && age==p.age;  
    }  
};  

size_t hash_value(const person& p)  
{  
    size_t seed = 0;  
    boost::hash_combine(seed, boost::hash_value(p.name));  
    boost::hash_combine(seed, boost::hash_value(p.age));  
    return seed;  
}  

int main()  
{  
    typedef boost::unordered_map<person,int> umap;  
    umap m;  
    person p1("Tom1",20);  
    person p2("Tom2",22);  
    person p3("Tom3",22);  
    person p4("Tom4",23);  
    person p5("Tom5",24);  
    m.insert(umap::value_type(p3, 100));  
    m.insert(umap::value_type(p4, 100));  
    m.insert(umap::value_type(p5, 100));  
    m.insert(umap::value_type(p1, 100));  
    m.insert(umap::value_type(p2, 100));  

    for(umap::iterator iter = m.begin(); iter != m.end(); iter++)  
    {  
        cout<<iter->first.name<<"\t"<<iter->first.age<<endl;  
    }  

    return 0;  
}  

output:

Tom1    20
Tom5    24
Tom4    23
Tom2    22
Tom3    22

必须要自定义operator==和hash_value。 重载operator==是因为，如果两个元素的hash_value的值相同，并不能断定这两个元素就相同，必须再调用operator==。 当然，如果hash_value的值不同，就不需要调用operator==了。

由于hash表的性能优势，它的使用面还是很广的，于是第三方的类库基本都提供了支持，比如MSVC中的和Boost中的<boost/unordered_map.hpp>
后来Boost的unordered_map被吸纳进了TR1 (C++ Technical Report 1)，然后在C++0x中被最终定了标准。参考：入口