C++ map

为了实现快速查找，map内部本身就是按序存储的（比如红黑树）。在我们插入<key, value>键值对时，就会按照key的大小顺序进行存储。Map的定义：

template < class Key, class T, class Compare = less<Key>, //入参为key
            //键         值                用于key比较的函数对象，与相对的greater
class Allocator = allocator<pair<const Key,T> > > 
                     //用于存储分配
class map; 

其中less实现：

template <class T> 
struct less : binary_function <T,T,bool> 
{  
  bool operator() (const T& x, const T& y) const  
    {return x<y;}  
};  

对Key排序

由上可知，按key排序，只需自定义一个用于比较的类就ok了。

例如：

struct CmpByKeyLength
{  
     bool operator()(const string& k1, const string& k2)
     {  
         return k1.length() < k2.length();  
      }  
}; 
int main()
{  
    map<string, int, CmpByKeyLength> name_score_map;  
    name_score_map["LiMin"] = 90;    
    name_score_map.insert(make_pair("Bing",99));  
    name_score_map.insert(make_pair("Albert",86));  
    for (map<string, int>::iterator iter = name_score_map.begin();  
          iter != name_score_map.end();  
          ++iter) 
    {  
         cout << *iter << endl;  
    }
  
    return 0;  
}    

 

 

对Value排序

对于value则既不能按Compare，也不可以用sort,因为sort只可用于序列（线性）容器，而map是集合容器（例如：红黑树）

Map中的元素类型为pair

template <class T1, class T2> struct pair  
{  
  typedef T1 first_type;  
  typedef T2 second_type;  
  
  T1 first;               //对应Key
  T2 second;          //对应Value
 
  //构造函数
  pair() : first(T1()), second(T2()) {}  
  pair(const T1& x, const T2& y) : first(x), second(y) {}  
  template <class U, class V>  
  pair (const pair<U,V> &p) : first(p.first), second(p.second) { }  
}  

此外，在<utility>头文件中，还为pair重载了 <  运算符

template<class _T1, class _T2>  
inline bool  operator < (const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)  
{ 
    return __x.first < __y.first  ||                                 //key不同
  (!(__y.first < __x.first) && __x.second < __y.second);        //key相同，则比较value
//为什么不用==呢？因为作为map的key必须实现<操作符的重载，至于==不能保证，而且浮点数…
}  

所以用map + vector即可实现对value 的排序

例如：

typedef pair< int, int> PAIR;  
bool cmp_by_value(const PAIR& lhs, const PAIR& rhs) {  
  return lhs.second < rhs.second;  
}  
struct CmpByValue {  
  bool operator()(const PAIR& lhs, const PAIR& rhs) {  
    return lhs.second < rhs.second;  
  }  
}; 
int main() {  
  map<int, int> myMap;  
  myMap [1] = 90;  
  myMap [2] = 79;  
  myMap.insert(make_pair(3,99));  
  myMap insert(make_pair(4,86));  
 //把map中元素转存到vector中   
  vector<PAIR> name_score_vec(myMap.begin(), myMap.end());  
  sort(name_score_vec.begin(), name_score_vec.end(), CmpByValue());  
  // sort(name_score_vec.begin(), name_score_vec.end(), cmp_by_value);  
  for (int i = 0; i != myMap.size(); ++i) {  
         cout << myMap [i] << endl;  
       }  
      return 0;  
 }  

Sort算法如下：

template <class RandomAccessIterator>  
void sort ( RandomAccessIterator first, RandomAccessIterator last );  
  
template <class RandomAccessIterator, class Compare>  
void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );