C++ STL中雜湊表Map 與 hash_map 介紹
0 為什麼需要hash_map
用過map吧?map提供一個很常用的功能,那就是提供key-value的儲存和查詢功能。例如,我要記錄一個人名和相應的儲存,而且隨時增加,要快速查詢和修改:
嶽不群-華山派掌門人,人稱君子劍 張三丰-武當掌門人,太極拳創始人 東方不敗-第一高手,葵花寶典 ...
這些資訊如果儲存下來並不複雜,但是找起來比較麻煩。例如我要找"張三丰"的資訊,最傻的方法就是取得所有的記錄,然後按照名字一個一個比較。如果要速度快,就需要把這些記錄按照字母順序排列,然後按照二分法查詢。但是增加記錄的時候同時需要保持記錄有序,因此需要插入排序。考慮到效率,這就需要用到二叉樹。講下去會沒完沒了,如果你使用STL 的map容器,你可以非常方便的實現這個功能,而不用關心其細節。關於map的資料結構細節,感興趣的朋友可以參看
#include <map> #include <string> using namespace std; ... map<string, string> namemap; //增加。。。 namemap["嶽不群"]="華山派掌門人,人稱君子劍"; namemap["張三丰"]="武當掌門人,太極拳創始人"; namemap["東方不敗"]="第一高手,葵花寶典"; ... //查詢。。 if(namemap.find("嶽不群") != namemap.end()){ ... }
不覺得用起來很easy嗎?而且效率很高,100萬條記錄,最多也只要20次的string.compare的比較,就能找到你要找的記錄;200萬條記錄事,也只要用21次的比較。
速度永遠都滿足不了現實的需求。如果有100萬條記錄,我需要頻繁進行搜尋時,20次比較也會成為瓶頸,要是能降到一次或者兩次比較是否有可能?而且當記錄數到200萬的時候也是一次或者兩次的比較,是否有可能?而且還需要和map一樣的方便使用。
答案是肯定的。這時你需要has_map. 雖然hash_map目前並沒有納入C++ 標準模板庫中,但幾乎每個版本的STL都提供了相應的實現。而且應用十分廣泛。在正式使用hash_map之前,先看看hash_map的原理。
1 資料結構:hash_map原理
這是一節讓你深入理解hash_map的介紹,如果你只是想囫圇吞棗,不想理解其原理,你倒是可以略過這一節,但我還是建議你看看,多瞭解一些沒有壞處。
hash_map基於hash table(雜湊表)。 雜湊表最大的優點,就是把資料的儲存和查詢消耗的時間大大降低,幾乎可以看成是常數時間;而代價僅僅是消耗比較多的記憶體。然而在當前可利用記憶體越來越多的情況下,用空間換時間的做法是值得的。另外,編碼比較容易也是它的特點之一。
其基本原理是:使用一個下標範圍比較大的陣列來儲存元素。可以設計一個函式(雜湊函式,也叫做雜湊函式),使得每個元素的關鍵字都與一個函式值(即陣列下標,hash值)相對應,於是用這個陣列單元來儲存這個元素;也可以簡單的理解為,按照關鍵字為每一個元素“分類”,然後將這個元素儲存在相應“類”所對應的地方,稱為桶。
但是,不能夠保證每個元素的關鍵字與函式值是一一對應的,因此極有可能出現對於不同的元素,卻計算出了相同的函式值,這樣就產生了“衝突”,換句話說,就是把不同的元素分在了相同的“類”之中。 總的來說,“直接定址”與“解決衝突”是雜湊表的兩大特點。
hash_map,首先分配一大片記憶體,形成許多桶。是利用hash函式,對key進行對映到不同區域(桶)進行儲存。其插入過程是:
- 得到key
- 通過hash函式得到hash值
- 得到桶號(一般都為hash值對桶數求模)
- 存放key和value在桶內。
其取值過程是:
- 得到key
- 通過hash函式得到hash值
- 得到桶號(一般都為hash值對桶數求模)
- 比較桶的內部元素是否與key相等,若都不相等,則沒有找到。
- 取出相等的記錄的value。
hash_map中直接地址用hash函式生成,解決衝突,用比較函式解決。這裡可以看出,如果每個桶內部只有一個元素,那麼查詢的時候只有一次比較。當許多桶內沒有值時,許多查詢就會更快了(指查不到的時候).
由此可見,要實現雜湊表, 和使用者相關的是:hash函式和比較函式。這兩個引數剛好是我們在使用hash_map時需要指定的引數。
2 hash_map 使用
2.1 一個簡單例項
不要著急如何把"嶽不群"用hash_map表示,我們先看一個簡單的例子:隨機給你一個ID號和ID號相應的資訊,ID號的範圍是1~2的31次方。如何快速儲存查詢。
#include <hash_map>
#include <string>
using namespace std;
int main(){
hash_map<int, string> mymap;
mymap[9527]="唐伯虎點秋香";
mymap[1000000]="百萬富翁的生活";
mymap[10000]="白領的工資底線";
...
if(mymap.find(10000) != mymap.end()){
...
}
夠簡單,和map使用方法一樣。這時你或許會問?hash函式和比較函式呢?不是要指定麼?你說對了,但是在你沒有指定hash函式和比較函式的時候,你會有一個預設的函式,看看hash_map的宣告,你會更加明白。下面是SGI STL的宣告:
template <class _Key, class _Tp, class _HashFcn = hash<_Key>, class _EqualKey = equal_to<_Key>, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) > class hash_map { ... }
也就是說,在上例中,有以下等同關係:
... hash_map<int, string> mymap; //等同於: hash_map<int, string, hash<int>, equal_to<int> > mymap;
Alloc我們就不要取關注太多了(希望深入瞭解Allocator的朋友可以參看標準庫 STL :Allocator能做什麼)
hash_map類在標頭檔案hash_map中,和所有其它的C++標準庫一樣,標頭檔案沒有副檔名。如下宣告:
#include <hash_map>
using namespace std;
using namespace stdext;
hash_map是一個聚合類,它繼承自_Hash類,包括一個vector,一個list和一個pair,其中vector用於儲存桶,list用於進行衝突處理,pair用於儲存key->value結構,簡要地偽碼如下:
class hash_map<class _Tkey, class _Tval>
{
private:
typedef pair<_Tkey, _Tval> hash_pair;
typedef list<hash_pair> hash_list;
typedef vector<hash_list> hash_table;
};
當然,這只是一個簡單模型,C++標準庫的泛型模版一向以巢狀複雜而聞名,初學時看類庫,無疑天書啊。微軟的hash_map類還聚合了hash_compare仿函式類,hash_compare類裡又聚合了less仿函式類,亂七八糟的。2.2 hash_map 的hash函式
hash< int>到底是什麼樣子?看看原始碼:
struct hash<int> { size_t operator()(int __x) const { return __x; } };
原來是個函式物件。在SGI STL中,提供了以下hash函式:
struct hash<char*>
struct hash<const char*>
struct hash<char>
struct hash<unsigned char>
struct hash<signed char>
struct hash<short>
struct hash<unsigned short>
struct hash<int>
struct hash<unsigned int>
struct hash<long>
struct hash<unsigned long>
也就是說,如果你的key使用的是以上型別中的一種,你都可以使用預設的hash函式。當然你自己也可以定義自己的hash函式。對於自定義變數,你只能如此,例如對於string,就必須自定義hash函式。例如:
struct str_hash{
size_t operator()(const string& str) const
{
unsigned long __h = 0;
for (size_t i = 0 ; i < str.size() ; i ++)
__h = 5*__h + str[i];
return size_t(__h);
}
};
//如果你希望利用系統定義的字串hash函式,你可以這樣寫:
struct str_hash{
size_t operator()(const string& str) const
{
return __stl_hash_string(str.c_str());
}
};
在宣告自己的雜湊函式時要注意以下幾點:
- 使用struct,然後過載operator().
- 返回是size_t
- 引數是你要hash的key的型別。
- 函式是const型別的。
如果這些比較難記,最簡單的方法就是照貓畫虎,找一個函式改改就是了。
現在可以對開頭的"嶽不群"進行雜湊化了 . 直接替換成下面的宣告即可:
map<string, string> namemap;
//改為:
hash_map<string, string, str_hash> namemap;
其他用法都不用邊。當然不要忘了吧str_hash的宣告以及標頭檔案改為hash_map。
你或許會問:比較函式呢?彆著急,這裡就開始介紹hash_map中的比較函式。
2.3 hash_map 的比較函式
在map中的比較函式,需要提供less函式。如果沒有提供,預設的也是less< Key> 。在hash_map中,要比較桶內的資料和key是否相等,因此需要的是是否等於的函式:equal_to< Key> 。先看看equal_to的原始碼:
//本程式碼可以從SGI STL
//先看看binary_function 函式宣告,其實只是定義一些型別而已。
template <class _Arg1, class _Arg2, class _Result>
struct binary_function {
typedef _Arg1 first_argument_type;
typedef _Arg2 second_argument_type;
typedef _Result result_type;
};
//看看equal_to的定義:
template <class _Tp>
struct equal_to : public binary_function<_Tp,_Tp,bool>
{
bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
};
如果你使用一個自定義的資料型別,如struct mystruct, 或者const char* 的字串,如何使用比較函式?使用比較函式,有兩種方法. 第一種是:過載==操作符,利用equal_to;看看下面的例子:struct mystruct{
int iID;
int len;
bool operator==(const mystruct & my) const{
return (iID==my.iID) && (len==my.len) ;
}
};
這樣,就可以使用equal_to< mystruct>作為比較函數了。另一種方法就是使用函式物件。自定義一個比較函式體:
struct compare_str{
bool operator()(const char* p1, const char*p2) const{
return strcmp(p1,p2)==0;
}
};
有了compare_str,就可以使用hash_map了。
typedef hash_map<const char*, string, hash<const char*>, compare_str> StrIntMap;
StrIntMap namemap;
namemap["嶽不群"]="華山派掌門人,人稱君子劍";
namemap["張三丰"]="武當掌門人,太極拳創始人";
namemap["東方不敗"]="第一高手,葵花寶典";
2.4 hash_map 函式
hash_map的函式和map的函式差不多。具體函式的引數和解釋,請參看:STL 程式設計手冊:Hash_map,這裡主要介紹幾個常用函式。
- hash_map(size_type n) 如果講究效率,這個引數是必須要設定的。n 主要用來設定hash_map 容器中hash桶的個數。桶個數越多,hash函式發生衝突的概率就越小,重新申請記憶體的概率就越小。n越大,效率越高,但是記憶體消耗也越大。
- const_iterator find(const key_type& k) const. 用查詢,輸入為鍵值,返回為迭代器。
- data_type& operator[](const key_type& k) . 這是我最常用的一個函式。因為其特別方便,可像使用陣列一樣使用。不過需要注意的是,當你使用[key ]操作符時,如果容器中沒有key元素,這就相當於自動增加了一個key元素。因此當你只是想知道容器中是否有key元素時,你可以使用find。如果你希望插入該元素時,你可以直接使用[]操作符。
- insert 函式。在容器中不包含key值時,insert函式和[]操作符的功能差不多。但是當容器中元素越來越多,每個桶中的元素會增加,為了保證效率,hash_map會自動申請更大的記憶體,以生成更多的桶。因此在insert以後,以前的iterator有可能是不可用的。
- erase 函式。在insert的過程中,當每個桶的元素太多時,hash_map可能會自動擴充容器的記憶體。但在sgi stl中是erase並不自動回收記憶體。因此你呼叫erase後,其他元素的iterator還是可用的。
3 相關hash容器
hash 容器除了hash_map之外,還有hash_set, hash_multimap, has_multiset, 這些容器使用起來和set, multimap, multiset的區別與hash_map和map的區別一樣,我想不需要我一一細說了吧。
4 其他
這裡列幾個常見問題,應該對你理解和使用hash_map比較有幫助。
4.1 hash_map和map的區別在哪裡?
- 建構函式。hash_map需要hash函式,等於函式;map只需要比較函式(小於函式).
- 儲存結構。hash_map採用hash表儲存,map一般採用紅黑樹(RB Tree)實現。因此其memory資料結構是不一樣的。
4.2 什麼時候需要用hash_map,什麼時候需要用map?
總體來說,hash_map 查詢速度會比map快,而且查詢速度基本和資料資料量大小,屬於常數級別;而map的查詢速度是log(n)級別。並不一定常數就比log(n)小,hash還有hash函式的耗時,明白了吧,如果你考慮效率,特別是在元素達到一定數量級時,考慮考慮hash_map。但若你對記憶體使用特別嚴格,希望程式儘可能少消耗記憶體,那麼一定要小心,hash_map可能會讓你陷入尷尬,特別是當你的hash_map物件特別多時,你就更無法控制了,而且hash_map的構造速度較慢。
現在知道如何選擇了嗎?權衡三個因素: 查詢速度, 資料量, 記憶體使用。
4.3 如何在hash_map中加入自己定義的型別?
你只要做兩件事, 定義hash函式,定義等於比較函式。下面的程式碼是一個例子:
#include <hash_map>
#include <string>
#include <iostream>
using namespace std;
//define the class
class ClassA{
public:
ClassA(int a):c_a(a){}
int getvalue()const { return c_a;}
void setvalue(int a){c_a;}
private:
int c_a;
};
//1 define the hash function
struct hash_A{
size_t operator()(const class ClassA & A)const{
// return hash<int>(classA.getvalue());
return A.getvalue();
}
};
//2 define the equal function
struct equal_A{
bool operator()(const class ClassA & a1, const class ClassA & a2)const{
return a1.getvalue() == a2.getvalue();
}
};
int main()
{
hash_map<ClassA, string, hash_A, equal_A> hmap;
ClassA a1(12);
hmap[a1]="I am 12";
ClassA a2(198877);
hmap[a2]="I am 198877";
cout<<hmap[a1]<<endl;
cout<<hmap[a2]<<endl;
return 0;
}
執行:
I am 12
I am 198877
4.4如何用hash_map替換程式中已有的map容器?
這個很容易,但需要你有良好的程式設計風格。建議你儘量使用typedef來定義你的型別:
typedef map<Key, Value> KeyMap;
當你希望使用hash_map來替換的時候,只需要修改:
typedef hash_map<Key, Value> KeyMap;
其他的基本不變。當然,你需要注意是否有Key型別的hash函式和比較函式。
4.5為什麼hash_map不是標準的?
具體為什麼不是標準的,我也不清楚,有個解釋說在STL加入標準C++之時,hash_map系列當時還沒有完全實現,以後應該會成為標準。如果誰知道更合理的解釋,也希望告訴我。但我想表達的是,正是因為hash_map不是標準的,所以許多平臺上安裝了g++編譯器,不一定有hash_map的實現。我就遇到了這樣的例子。因此在使用這些非標準庫的時候,一定要事先測試。另外,如果考慮到平臺移植,還是少用為佳。
常見問題:
本來想用hash_map實現大數量的快速查詢,後來發現效率並不快,而且有些問題也很不解,比如看如下程式碼:
#include <iostream>
#include <hash_map.h>
using namespace std;
int main(){
hash_map<int,string> hm(3); //初始化hash_map的桶的個數
hm.insert(make_pair(0,"hello"));
hm.insert(make_pair(1,"ok"));
hm.insert(make_pair(2,"bye"));
hm.insert(make_pair(3,"world"));
cout<<hm.size()<<endl;
cout<<hm.bucket_count()<<endl;
return 0;
}
輸出結果:
4
53
對這個結果很疑惑,明明我定義了桶的個數,為什麼後面得到桶的個數為53?
hash_map預設對int型別的Key如何hash,hash函式是什麼?
如何使得查詢能更高效?可以用空間來換
各位大俠請教啊
這是我對hash的曾經的一點嘗試,僅供參考:
C/C++ code
#include <iostream>
#include <map>
#include <string>
#ifdef __GNUC__
#include <ext/hash_map>
#else
#include <hash_map>
#endif
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <unordered_map>
#endif
namespace std
{
using namespace __gnu_cxx;
}
namespace __gnu_cxx
{
template<> struct hash< std::string >
{
size_t operator()( const std::string& x ) const
{
return hash< const char* >()(x.c_str());
}
};
}
int main()
{
std::map<std::string, std::string> stdMap;
stdMap["_GLIBCXX_STD"] = "std";
stdMap["_GLIBCXX_BEGIN_NESTED_NAMESPACE"] = "+namespace";
stdMap["_GLIBCXX_BEGIN_NAMESPACE"] = "+namespace";
stdMap["_GLIBCXX_END_NESTED_NAMESPACE"] = "}";
stdMap["_GLIBCXX_END_NAMESPACE"] = "}";
stdMap["_GLIBCXX_END_NAMESPACE_TR1"] = "}";
stdMap["_GLIBCXX_BEGIN_NAMESPACE_TR1"] = "-namespace tr1 {";
stdMap["_GLIBCXX_STD2"] = "2std";
stdMap["_GLIBCXX_BEGIN_NESTED_NAMESPACE2"] = "2+namespace";
stdMap["_GLIBCXX_BEGIN_NAMESPACE2"] = "2+namespace";
stdMap["_GLIBCXX_END_NESTED_NAMESPACE2"] = "2}";
stdMap["_GLIBCXX_END_NAMESPACE2"] = "2}";
stdMap["_GLIBCXX_END_NAMESPACE_TR12"] = "2}";
stdMap["_GLIBCXX_BEGIN_NAMESPACE_TR12"] = "2-namespace tr1 {";
stdMap["_XXGLIBCXX_END_NAMESPACE_TR12"] = "X2}";
stdMap["_XXGLIBCXX_BEGIN_NAMESPACE_TR12"] = "X2-namespace tr1 {";
std::hash_map<std::string, std::string> hashMap;
hashMap["_GLIBCXX_STD"] = "std";
hashMap["_GLIBCXX_BEGIN_NESTED_NAMESPACE"] = "+namespace";
hashMap["_GLIBCXX_BEGIN_NAMESPACE"] = "+namespace";
hashMap["_GLIBCXX_END_NESTED_NAMESPACE"] = "}";
hashMap["_GLIBCXX_END_NAMESPACE"] = "}";
hashMap["_GLIBCXX_END_NAMESPACE_TR1"] = "}";
hashMap["_GLIBCXX_BEGIN_NAMESPACE_TR1"] = "-namespace tr1 {";
hashMap["_GLIBCXX_STD2"] = "2std";
hashMap["_GLIBCXX_BEGIN_NESTED_NAMESPACE2"] = "2+namespace";
hashMap["_GLIBCXX_BEGIN_NAMESPACE2"] = "2+namespace";
hashMap["_GLIBCXX_END_NESTED_NAMESPACE2"] = "2}";
hashMap["_GLIBCXX_END_NAMESPACE2"] = "2}";
hashMap["_GLIBCXX_END_NAMESPACE_TR12"] = "2}";
hashMap["_GLIBCXX_BEGIN_NAMESPACE_TR12"] = "2-namespace tr1 {";
hashMap["_XXGLIBCXX_END_NAMESPACE_TR12"] = "X2}";
hashMap["_XXGLIBCXX_BEGIN_NAMESPACE_TR12"] = "X2-namespace tr1 {";
#ifdef __GXX_EXPERIMENTAL_CXX0X__
std::unordered_map<std::string, std::string> unorderedMap;
unorderedMap["_GLIBCXX_STD"] = "std";
unorderedMap["_GLIBCXX_BEGIN_NESTED_NAMESPACE"] = "+namespace";
unorderedMap["_GLIBCXX_BEGIN_NAMESPACE"] = "+namespace";
unorderedMap["_GLIBCXX_END_NESTED_NAMESPACE"] = "}";
unorderedMap["_GLIBCXX_END_NAMESPACE"] = "}";
unorderedMap["_GLIBCXX_END_NAMESPACE_TR1"] = "}";
unorderedMap["_GLIBCXX_BEGIN_NAMESPACE_TR1"] = "-namespace tr1 {";
unorderedMap["_GLIBCXX_STD2"] = "2std";
unorderedMap["_GLIBCXX_BEGIN_NESTED_NAMESPACE2"] = "2+namespace";
unorderedMap["_GLIBCXX_BEGIN_NAMESPACE2"] = "2+namespace";
unorderedMap["_GLIBCXX_END_NESTED_NAMESPACE2"] = "2}";
unorderedMap["_GLIBCXX_END_NAMESPACE2"] = "2}";
unorderedMap["_GLIBCXX_END_NAMESPACE_TR12"] = "2}";
unorderedMap["_GLIBCXX_BEGIN_NAMESPACE_TR12"] = "2-namespace tr1 {";
unorderedMap["_XXGLIBCXX_END_NAMESPACE_TR12"] = "X2}";
unorderedMap["_XXGLIBCXX_BEGIN_NAMESPACE_TR12"] = "X2-namespace tr1 {";
#endif
for (int i = 0; i < 5; ++i)
{
const clock_t t = clock();
for (int j = 0; j < 1000000; ++j) stdMap.find("testfindkey");
std::cout << "stdMap " << i + 1 << " : " << clock() - t << std::endl;
}
std::cout << "/n---------------/n" << std::endl;
for (int i = 0; i < 5; ++i)
{
const clock_t t = clock();
for (int j = 0; j < 1000000; ++j) hashMap.find("testfindkey");
std::cout << "hashMap " << i + 1 << " : " << clock() - t << std::endl;
}
#ifdef __GXX_EXPERIMENTAL_CXX0X__
std::cout << "/n---------------/n" << std::endl;
for (int i = 0; i < 5; ++i)
{
const clock_t t = clock();
for (int j = 0; j < 1000000; ++j) unorderedMap.find("testfindkey");
std::cout << "unorderedMap " << i + 1 << " : " << clock() - t << std::endl;
}
#endif
return 0;
}
如果你使用的vc自帶的hash函式,那麼它的定義中如下:
template<class _Kty, class _Pr = less>
class hash_compare1
{ // traits class for hash containers
public:
//const static long lBucketSize = 0;
enum
{ // parameters for hash table
bucket_size = 4, // 0 < bucket_size
min_buckets = 8 // min_buckets = 2 ^^ N, 0 < N
};
。。。
每次增長會2倍增加預分配記憶體,你的hash_map是哪個版本的?