map的默認排序和自定義排序

STL的容器map為我們處理有序key-value形式數據提供了非常大的便利，由於內部紅黑樹結構的存儲，查找的時間復雜度為O(log2N)。

一般而言，使用map的時候直接采取map<typename A, typename B>的形式即可，map的內部實現默認使用A類型變量的升序來排序map的值。

但是有時我們需要對map的值做特殊的排序(不經其他容器的輔助)，這就需要在定義map變量時做些特殊的處理。

STL中map的定義是：

template<class _Kty,
    class _Ty,
    class _Pr = less<_Kty>,
    class _Alloc = allocator<pair<const _Kty, _Ty>>>
    class map
        : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>>
    {    

這是一個模板類，我們的特殊處理主要改造的就是class _Pr = less<_Kty>，並且從這里我們也能看到，無論做哪種修改，排序都是針對key而言的，要實現value的自定義排序，

不是修改_Pr類型能完成的。

替換_Pr的也必須是一個類型，即至少我們要自己創建一個類型，用來做key的比較。自然，我們需要做的是重載函數調用操作符"()"，一般的形式為

class T{
public:
    bool operator()(const T& lhs, const T& rhs)const
    {
        ...    
    }    
};

代碼需包含頭文件<algorithm>、<functional>。

下面是常見的一些自定義排序：

a.對基本類型的key以降序排列

　　map默認提供的是less<_Kty>類型的排序方式，閱讀STL源碼

template<class _Ty = void>
    struct less
    {    // functor for operator<
    _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty first_argument_type;
    _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty second_argument_type;
    _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef bool result_type;

    constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        {    // apply operator< to operands
        return (_Left < _Right);
        }
    };

　　修改上述代碼的第10行，為修改后的類型起一個自定義名字很簡單，不過STL已經為我們提供了整個類型定義：

template<class _Ty = void>
    struct greater
    {    // functor for operator>
    _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty first_argument_type;
    _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef _Ty second_argument_type;
    _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS typedef bool result_type;

    constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
        {    // apply operator> to operands
        return (_Left > _Right);
        }
    };

 

　　我們直接使用就行：

std::map<int, int, std::greater<int>> mi;
    for (int i = 0; i < 5; i++)
    {
        mi[i] = i * 2;
    }

    std::for_each(mi.begin(), mi.end(), 
        [](const std::map<int, int, std::greater<int>>::value_type& vl) {
        cout << "key:" << vl.first << "　　value:" << vl.second << '\n';
    });

 

　　對應的輸出為：

　　

 

　　這里，我們實現了按key降序排列的目的。

 b.為自定義類型的key做排序：

　　自定義類型的key定義map時(使用map默認排序)，我們一般都要做一件事：為自定義類型重載“<”操作符，顯然，這是為了map創建對象時可以使用less。

　　因此，我們替換less<_Kty>也同樣是要做這樣的事：自定義排序規則，  比如： 

class MyKey {
public:
    MyKey(int fidx = 0, int sidx = 0)
        :m_firstIdx(fidx), m_secondIdx(sidx) {}

    int m_firstIdx;
    int m_secondIdx;
};

class MyCompare{
public:
    bool operator()(const MyKey& lhs, const MyKey& rhs)const
    {
        if (lhs.m_firstIdx > rhs.m_firstIdx)
        {
            return true;
        }
        else if (lhs.m_firstIdx == rhs.m_firstIdx)
        {
            return lhs.m_secondIdx > rhs.m_secondIdx;
        }
        return false;
    }
};

class MyCompare2 {
public:
    bool operator()(const MyKey& lhs, const MyKey& rhs)const
    {
        return lhs.m_firstIdx > rhs.m_firstIdx;
    }
};

使用MyCompare：

std::map<MyKey, int, MyCompare> mi;
    for (int i = 0; i < 5; i++)
    {
        mi[MyKey(i * 2, i)] = i * 2;
    }

    std::for_each(mi.begin(), mi.end(), 
        [](const std::map<MyKey, int, MyCompare>::value_type& vl) {
        cout << "key:" << vl.first.m_firstIdx << "-" << vl.first.m_secondIdx << "  value:" << vl.second << '\n';
    });

使用MyCompare2:

std::map<MyKey, int, MyCompare2> mi;
    for (int i = 0; i < 5; i++)
    {
        mi[MyKey(i * 2, i)] = i * 2;
    }

    std::for_each(mi.begin(), mi.end(), 
        [](const std::map<MyKey, int, MyCompare2>::value_type& vl) {
        cout << "key:" << vl.first.m_firstIdx << "-" << vl.first.m_secondIdx << "  value:" << vl.second << '\n';
    });

　　以上兩種有相同的輸出：

 我們實現了自定義類型自定義排序的目的。

 

可以看到，使用map其實有很大的自由度，我們完全可以定制自己的map，為我們解決問題、精簡代碼帶來很大的便利。