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上報錯。