1、map按照value排序

首先想到的是利用stl中的sort方法，但sort方法只能只能对线性容器进行排序（vector，list，deque），对于map这种关联型容器

，会破坏数据结构，可以迂回下，把map中的元素放到vector中，并且自定义容器中元素的比较方法。

#include<string>
#include

 2、map按照key排序

首先map的模板定义为：

tempate ,
typename _Alloc=std::allocatorconst _Key,_Ip>>>
class map{
public:
   typedef _Key key_type;
   typedef _Ip mapped_type;
   typedef std::pair<const _Key,_Ip> 
   typedef _Compare key_compare;
   typedef _Alloc allocator_type;     
};

可以看到map类模板有4个模板参数:_Key,_Tp,_Compare,_Alloc，其中_Compare与_Alloc已经有了默认参数。　

其中less和greater是两个关系类仿函数，可以用来指定key的顺序，模板如下：

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

结论：

所以当我们打算定义map的key排序时，就必须在定义一个map类型对象的时候，指定一个有严格顺序或者强序的Comapre类。

//自定义map的key排列顺序
map<string,int,greater<string>> m1;
struct myCompare {
 bool operator()(const string& l, const string& r)const
 {
  return l.length() > r.length();
 }
};
map<string,int,myCompare> m2;

3、自定义map不区分大小写

通过自定义仿函数来实现不区分大小写:

//方法1
struct NoCaseCompare{
    bool operotor()(cosnt std::string& lhs,const std::string& rhs) cosnt
    {
        std::string s1(lhs);
        for(size_t i=0; i < lhs.size(); ++i) {
            if(s1[i] >= 'a' && s1[i] <= 'z'){
                 s1[i] -= 32;
             }
        }
        std::string s2(rhs);
        for(size_t i=0; i < rhs.size(); ++i) {
           if(s2[i] >= 'a' && s2[i] <= 'z'){
                 s2[i] -= 32;
             }
        }
        return s1.comapre(s2) >= 0 ? false : true;
    }
};
map<string,int,NoCaseCompare> m_map;

//方法2
struct ci_less : std::binary_functionstring, std::string, bool>
{
  // case-independent (ci) compare_less binary function
  struct nocase_compare : public std::binary_functionchar, unsigned char, bool>
  {
    bool operator()(const unsigned char &c1, const unsigned char &c2) const
    {
      return tolower(c1) < tolower(c2);
    }
  };
  bool operator()(const std::string &s1, const std::string &s2) const
  {
    return std::lexicographical_compare(s1.begin(), s1.end(), // source range
                                        s2.begin(), s2.end(), // dest range
                                        nocase_compare());    // comparison
  }
};
map<string, int, ci_less> m_map;

4、