C++中std::map自定義排序與std::unordered_map自定義哈希函數

　　前面部分轉自C++ STL map的自定義排序，

　　std::map 的定義與特性，用法詳解參考C++ map用法詳解。

//所在頭文件：<map>, std::map 類模板, std::map 通常由二叉搜索樹實現。
template < class Key,                                     // map::key_type
           class T,                                       // map::mapped_type
           class Compare = less<Key>,                     // map::key_compare
           class Alloc = allocator<pair<const Key,T> >    // map::allocator_type
           > class map;

　　std::unorder_map的定義如下：

//頭文件unorder_map,
template<class Key,
    class Ty,
    class Hash = std::hash<Key>,
    class Pred = std::equal_to<Key>,
    class Alloc = std::allocator<std::pair<const Key, Ty> > >
    class unordered_map;
    > class unordered_map

一、map按鍵值Key排序

1. 默認按照less<key>升序排列

　　輸入8，Key升序，Value隨機：

#include<iostream>
#include<map>
using namespace std;
int main()
{
    srand((unsigned)time(NULL));
    multimap<int,int>mp;
// multimap第三個參數默認為less<Key>,即 less<int>
    int n;
    cin>>n;
    int a,b;
    for(int i=0; i<n; i++)
    {
        a=rand()%4;
        b=rand()%4;
        //插入
        mp.insert(pair<int,int>(a,b));
    }
    map<int,int>::iterator iter;
    //遍歷輸出
    for(iter=mp.begin(); iter!=mp.end(); iter++)
        cout<<iter->first<<" "<<iter->second<<endl;
    return 0;
}

2. 定義map時，用greater< Key>實現按Key值遞減插入數據

multimap<int,int,greater<int> >mp;
//注意<int>后空一格

3. 當Key值為自定義的類時

　　方法1：寫一個函數對象1（仿函數），重載operator()

　　注意：函數對象：即調用操作符的類，其對象常稱為函數對象（function object），它們是行為類似函數的對象。表現出一個函數的特征，就是通過“對象名+(參數列表)”的方式使用一個 類，其實質是對operator()操作符的重載。

#include<iostream>
#include<map>
using namespace std;
typedef struct tagIntPlus
{
    int num,i;
}IntPlus;
//自定義比較規則
//注意operator是(),不是＜
struct Cmp
{
    bool operator () (IntPlus const &a,IntPlus const &b)const
    {
        if(a.num!=b.num)
            return a.num<b.num;
        else return a.i<b.i;
    }
};
int main()
{
    srand((unsigned)time(NULL));
    //注意此處一定要有Cmp，否則無法排序會報錯
    multimap<IntPlus,int,Cmp>mp;
    int n;
    cin>>n;
    int a,b;
    IntPlus intplus;
    for(int i=0; i<n; i++)
    {
        a=rand()%4;
        b=rand()%4;
        intplus.num=a;
        intplus.i=b;
        mp.insert(pair<IntPlus,int>(intplus,i));
    }
    map<IntPlus,int>::iterator iter;
    for(iter=mp.begin(); iter!=mp.end(); iter++)
        cout<<iter->first.num<<" "<<iter->first.i<<" "<<iter->second<<endl;
    return 0;
}

　　方法2：在類里重載重載operator<

typedef struct tagIntPlus
{
    int num,i;
    bool operator < (tagIntPlus const& intplus)const
    {
        //當num不等時
        //前一個對象的num>后一個時返回true,降序排列。
        //反之升序排列
        if(num!=intplus.num)
            return num>intplus.num;
        //當num相等時
        //前一個對象的i<后一個時返回true,升序排列
        else return i<intplus.i;
    }
}IntPlus;

　　注意只重載小於號,不要去重載大於號，如果想改變為 升 / 降序列,只需改變判斷條件即可。

multimap<IntPlus,int>mp;

　　主函數只需將第一種方法中的map中的Cmp去掉即可。

4. 用char*類型作為map的主鍵

　　find或count時，默認使用== 進行判斷，char*只是指針，如果兩個字符串值相同，但是地址不同，是無法匹配的。所以最好使用std::string。如果非要用char*，需要使用find_if函數並且用bind2sd函數指定比較函數。

#include <map>
#include <algorithm>
#include <iostream>
 
using namespace std;
 
bool search(pair<char*, int> a, const char* b)
{
    return strcmp(a.first, b) == 0 ? true : false;
}
int main()
{
    map<char*, int> test;
    test.insert(pair<char*, int>("abc", 1));
 
    map<char*, int>::const_iterator iter = find_if(test.begin(), test.end(),  bind2nd(ptr_fun(search), "abc"));
 
    if (iter != test.end())
    {
        cout<< "find : " << iter->first << endl;
    }
 
    return 0;
}

二、map按值Value排序

　　再次強調不能用sort，只能將map中數據壓入能用sort的容器，如vector

#include<iostream>
#include<map>
#include<vector>
#include<algorithm>//sort
using namespace std;

typedef struct tagIntPlus
{
    int num,i;
} IntPlus;

typedef pair<tagIntPlus,int> PAIR;

　　必須有Cmp。雖然之后會sort，map的排序並不重要，但是map輸入數據時需要比較Key值，沒有會報錯。注意這里說的是自定義類型作為key需要加Cmp函數。

struct Cmp
{
    bool operator () (IntPlus const &a,IntPlus const &b)const
    {
        if(a.num!=b.num)
            return a.num<b.num;
        else return a.i<b.i;
    }
};

　　map會按鍵值Key升序排列，Value值無要求。定義vector的排序接口如下

bool vec_cmp(PAIR const&a,PAIR const&b)
{
    if(a.first.num!=b.first.num)
        return a.first.num<b.first.num;
    else
    {
        if(a.first.i!=b.first.i)
            return a.first.i<b.first.i;
        else return a.second>b.second;
    }
}

　　上面需重新定義Key升序排列，否則sort之后僅按Value降序排列，Key值被打亂。

int main()
{
    srand((unsigned)time(NULL));
    multimap<IntPlus,int,Cmp>mp;
    int n;
    cin>>n;
    int a,b;
    IntPlus intplus;
    for(int i=0; i<n; i++)
    {
        a=rand()%4;
        b=rand()%4;
        intplus.num=a;
        intplus.i=b;
        mp.insert(pair<IntPlus,int>(intplus,i));
    }
    map<IntPlus,int>::iterator iter;
    cout<<"排序前:"<<endl;
    for(iter=mp.begin(); iter!=mp.end(); iter++)
        cout<<iter->first.num<<"|"<<iter->first.i<<"|"<<iter->second<<endl;

　　排序前:

    cout<<"排序后:"<<endl;
    vector<PAIR>vec(mp.begin(),mp.end());
    sort(vec.begin(),vec.end(),vec_cmp);
    int size=vec.size();
    for(int i=0;i<size;i++)
        cout<<vec[i].first.num<<"|"<<vec[i].first.i<<"|"<<vec[i].second<<endl;
    return 0;
}

 三、std::unorder_map自定義鍵值類型(轉載)

　　對於unordered_map而言，當我們插入<key, value>的時候，需要哈希函數的函數對象對key進行hash，又要利用等比函數的函數對象確保插入的鍵值對沒有重復。然而，當我們自定義類型時，c++標准庫並沒有對應的哈希函數和等比函數的函數對象。因此需要分別對它們進行定義。

　　因為都是函數對象，它們兩個的實際定義方法並沒有很大差別。不過后者比前者多了一個方法。因為等比函數的函數對象默認值std::equal_to<key>內部是通過調用操作符"=="進行等值判斷，因此我們可以直接在自定義類里面進行operator==()重載（成員和友元都可以）。

　　因此，如果要將自定義類型作為unordered_map的鍵值，需如下兩個步驟：

　　　　a-定義哈希函數的函數對象；

　　　　b-定義等比函數的函數對象或者在自定義類里重載operator==()。

　　為了避免重復，下文以討論哈希函數的函數對象為主，參數4則是通過直接在自定義類里面對operator==()進行重載。

　　首先簡要介紹一下函數對象 (在一、二部分已介紹) 的概念：在《C++ Primer Plus》里面，函數對象是可以以函數方式與()結合使用的任意對象。這包括函數名、指向函數的指針和重載了“operator()”操作符的類對象。基於此，我們提出3個方法。

方法1：std::function

　　利用std::function為person_hash()構建函數實例。初始化時，這個函數實例就會被分配那個指向person_hash()的指針（通過構造函數實現），如下所示。

#include <iostream>
#include <unordered_map>
#include <string>
#include <functional>

using namespace std;

class Person{
public:
    string name;
    int age;

    Person(string n, int a){
        name = n;
        age = a;
    }
    bool operator==(const Person & p) const 
    {
       return name == p.name && age == p.age;
    }
};

size_t person_hash( const Person & p ) 
{
    return hash<string>()(p.name) ^ hash<int>()(p.age);
}

int main(int argc, char* argv[])
{
    //ERRO: unordered_map<Person,int,decltype(&person_hash)> ids;
    //ERRO: unordered_map<Person,int,person_hash> ids(100, person_hash );
    //OK: unordered_map<Person, int, decltype(&person_hash)> ids(100, person_hash );
    unordered_map<Person,int,function<size_t( const Person& p )>> ids(100, person_hash); //需要把person_hash傳入構造函數
    ids[Person("Mark", 17)] = 40561;
    ids[Person("Andrew",16)] = 40562;
    for ( auto ii = ids.begin() ; ii != ids.end() ; ii++ )
        cout << ii->first.name 
        << " " << ii->first.age 
        << " : " << ii->second 
        << endl;
        return 0;
}

　　因為std::function構建對象的表達過於復雜，我們可以利用C++11新增的關鍵字decltype。它可以直接獲取自定義哈希函數的類型，並把它作為參數傳送。因此，ids的聲明可以改成下面這樣。

unordered_map<Person,int,decltype(&person_hash)> ids(100, person_hash);

　　另外，我們還可以引入c++11新支持的lambda expression，程序如下。

#include <iostream>
#include <unordered_map>
#include <string>
#include <functional>

using namespace std;

class Person{
public:
    string name;
    int age;

    Person(string n, int a){
        name = n;
        age = a;
    }

    bool operator==(const Person & p) const 
    {
        return name == p.name && age == p.age;
    }
};

int main(int argc, char* argv[])
{
    unordered_map<Person,int,std::function<size_t (const Person & p)>>
    ids(100, []( const Person & p)
             {
                 return hash<string>()(p.name) ^ hash<int>()(p.age);
             } );
    ids[Person("Mark", 17)] = 40561;
    ids[Person("Andrew",16)] = 40562;
    for ( auto ii = ids.begin() ; ii != ids.end() ; ii++ )
        cout << ii->first.name 
        << " " << ii->first.age
        << " : " << ii->second 
        << endl;
        return 0;
}

　　但是，使用lambda有2個弊端：

1. 我們就無法使用decltype獲取函數對象的類型，而只能用更復雜的std::function方法。

2. 程序的可讀性下降。

 

方法2：重載operator()的類

 

　　方法2就是利用重載operator()的類，將哈希函數打包成可以直接調用的類。此時，雖然我們仍然需要第3個參數，但是我們不需要將函數對象的引用傳入構造器里。因為unordered_map會追蹤類定義，當需要獲得哈希時，它可以動態地構造對象並傳遞數據，如下所示。

#include <iostream>
#include <string>
#include <unordered_map>
#include <functional>
using namespace std;

class Person{
public:
    string name;
    int age;

    Person(string n, int a){
        name = n;
        age = a;
    }

    bool operator==(const Person & p) const 
    {
        return name == p.name && age == p.age;
    }
};

struct hash_name{
    size_t operator()(const Person & p) const{
        return hash<string>()(p.name) ^ hash<int>()(p.age);
    }
};

int main(int argc, char* argv[]){
    unordered_map<Person, int, hash_name> ids; //不需要把哈希函數傳入構造器
    ids[Person("Mark", 17)] = 40561;
    ids[Person("Andrew",16)] = 40562;
    for ( auto ii = ids.begin() ; ii != ids.end() ; ii++ )
        cout << ii->first.name 
        << " " << ii->first.age
        << " : " << ii->second
        << endl;
    return 0;
}

方法3：模板定制

　　unordered_map第3個參數的默認參數是std::hash<Key>，實際上就是模板類。那么我們就可以對它進行模板定制，如下所示。

#include <iostream>
#include <unordered_map>
#include <string>
#include <functional>
using namespace std;

typedef pair<string,string> Name;

namespace std {
    template <> //function-template-specialization
        class hash<Name>{
        public :
            size_t operator()(const Name &name ) const
            {
                return hash<string>()(name.first) ^ hash<string>()(name.second);
            }
    };
};

int main(int argc, char* argv[])
{
    unordered_map<Name,int> ids;
    ids[Name("Mark", "Nelson")] = 40561;
    ids[Name("Andrew","Binstock")] = 40562;
    for ( auto ii = ids.begin() ; ii != ids.end() ; ii++ )
        cout << ii->first.first 
             << " " << ii->first.second 
             << " : " << ii->second
             << endl;
    return 0;
}

　　當我們將模板訂制包含在定義類的頭文件中時，其他人無需額外工作，就可以直接用我們的類作為任何無序容器的鍵。這對於要使用我們自定義類的人來說，絕對是最方便的。因此，如果你想要在多個地方用這個類，方法3是最好的選擇。當然，你要確保自己的hash function不會影響std空間里的其他類。

————————————————

額外案例：等比函數的函數對象

　　下例是哈希函數對象和等比函數對象都采用模板定制的方法。

#include <iostream>
#include <string>
#include <unordered_map>
#include <functional>
using namespace std;

class Person{
public:
    string name;
    int age;

    Person(string n, int a){
        name = n;
        age = a;
    }
};

namespace std{
    template<>
    struct hash<Person>{//哈希的模板定制
    public:
        size_t operator()(const Person &p) const 
        {
            return hash<string>()(p.name) ^ hash<int>()(p.age);
        }
        
    };
    
    template<>
    struct equal_to<Person>{//等比的模板定制
    public:
        bool operator()(const Person &p1, const Person &p2) const
        {
            return p1.name == p2.name && p1.age == p2.age;
        }
        
    };
}

int main(int argc, char* argv[]){
    unordered_map<Person, int> ids;
    ids[Person("Mark", 17)] = 40561;
    ids[Person("Andrew",16)] = 40562;
    for ( auto ii = ids.begin() ; ii != ids.end() ; ii++ )
        cout << ii->first.name 
        << " " << ii->first.age
        << " : " << ii->second
        << endl;
    return 0;
}

————————————————