unorder_map 基本操作

map和unordered_map的差别

还不知道或者搞不清unordered_map和map是什么的，请见： 
http://blog.csdn.net/billcyj/article/details/78065438

需要引入的头文件不同

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

内部实现机理不同

map： map内部实现了一个红黑树（红黑树是非严格平衡二叉搜索树，而AVL是严格平衡二叉搜索树），红黑树具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素。因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行的操作。map中的元素是按照二叉搜索树（又名二叉查找树、二叉排序树，特点就是左子树上所有节点的键值都小于根节点的键值，右子树所有节点的键值都大于根节点的键值）存储的，使用中序遍历可将键值按照从小到大遍历出来。 
unordered_map: unordered_map内部实现了一个哈希表（也叫散列表，通过把关键码值映射到Hash表中一个位置来访问记录，查找的时间复杂度可达到O(1)，其在海量数据处理中有着广泛应用）。因此，其元素的排列顺序是无序的。哈希表详细介绍

优缺点以及适用处

map：

1. 优点： 
   
   1. 有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作
   2. 红黑树，内部实现一个红黑书使得map的很多操作在lgn的时间复杂度下就可以实现，因此效率非常的高

2. 缺点： 空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点、孩子节点和红/黑性质，使得每一个节点都占用大量的空间

3. 适用处：对于那些有顺序要求的问题，用map会更高效一些

unordered_map：

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

总结： 
1. 内存占有率的问题就转化成红黑树 VS hash表 , 还是unorder_map占用的内存要高。 
2. 但是unordered_map执行效率要比map高很多 
3. 对于unordered_map或unordered_set容器，其遍历顺序与创建该容器时输入的顺序不一定相同，因为遍历是按照哈希表从前往后依次遍历的

map和unordered_map的使用

unordered_map的用法和map是一样的，提供了 insert，size，count等操作，并且里面的元素也是以pair类型来存贮的。其底层实现是完全不同的，上方已经解释了，但是就外部使用来说却是一致的。

C++ Map常见用法说明

常用操作汇总举例：

#include <iostream>  
#include <unordered_map>  
#include <map>
#include <string>  
using namespace std;  
int main()  
{  
    unordered_map<int, string> myMap={{ 5, "张大" },{ 6, "李五" }};//使用{}赋值
    myMap[2] = "李四";  //使用[ ]进行单个插入，若已存在键值2，则赋值修改，若无则插入。
    myMap.insert(pair<int, string>(3, "陈二"));//使用insert和pair插入

    //遍历输出+迭代器的使用
    auto iter = myMap.begin();//auto自动识别为迭代器类型unordered_map<int,string>::iterator
    while (iter!= myMap.end())
    {  
        cout << iter->first << "," << iter->second << endl;  
        ++iter;  
    }  

    //查找元素并输出+迭代器的使用
    auto iterator = myMap.find(2);//find()返回一个指向2的迭代器
    if (iterator != myMap.end())
        cout << endl<< iterator->first << "," << iterator->second << endl;  
    system("pause");  
    return 0;  
}  

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

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

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

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

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

  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;   
      }  
  };  
    
  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;  
  } 

  

  输出为：(根据age进行了排序的结果)

  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

   

  unordered_map使用案例：

  

  #include<string>  
  #include<iostream>  
  #include<unordered_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 name==p.name && age==p.age;  
      }  
  };  
    
  size_t hash_value(const person& p)  
  {  
      size_t seed = 0;  
      std::hash_combine(seed, std::hash_value(p.name));  
      std::hash_combine(seed, std::hash_value(p.age));  
      return seed;  
  }  
    
  int main()  
  {  
      typedef std::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;  
  }  

  

  对于hash_value的重载没有成功，在vs2013上报错。