map hash_map unordered_map 性能测试

最新推荐文章于 2023-04-07 16:14:13 发布
最新推荐文章于 2023-04-07 16:14:13 发布
阅读量793 收藏
点赞数
分类专栏： 算法 数据结构 加密


2012年1月8日  | by zieckey  | 标签: hash_map, map, STL, unordered_map, 关联容器, 性能比较, 用法示例

by zieckey

map hash_map unordered_map 性能测试
先给结论：
1. std::tr1::unordered_map 与 std::ext/hash_map
相对而言，遍历、查找等操作unordered_map要优于hash_map。hash_map的删除操作稍稍优于unordered_map。插入操作随着数据量的变化，10000以内时hash_map稍稍占优，10000以上的数据时，unordered_map 要稍稍快于hash_map。
2. std::tr1::unordered_map 与 std::map
unordered_map在元素个数小于1000的时候，遍历性能稍稍低于map 25%左右，一旦大于元素个数大于1000，起遍历所花时间较map多2~3倍。
因此，当我们遍历较多时，请考虑使用map而不是unordered_map。另外，当我们需要一个有序的关联容器的时候，我们必须选择map，因为 unordered_map 内部元素不是有序的，这一点从名字都可以看出来。
测试条件：
gcc version 4.2.1 20070719  [FreeBSD]
FreeBSD  7.2-RELEASE #0: Fri May  1 07:18:07 UTC 2009     root@driscoll.cse.buffalo.edu:/usr/obj/usr/src/sys/GENERIC  amd64
Intel(R) Xeon(R) CPU           E5620  @ 2.40GHz 16核
测试程序说明：
先准备好n个字符串随机的MD5字符串做为key，然后分别对3个容器进行插入、遍历、查找、删除操作。
例如，n=100的时候，插入是指插入100个随机MD5 key；遍历是指对容器遍历一次；查找是指分别对这个100个随机的MD5 key做查找操作（即查找100次）；删除是指挨个删除这个100个随机MD5 key。
测试数据如下表：
插入，单位us 100 1K 10K 100K 1M 10M
std::map 272 3485 43767 538052 3938154 45533490
std::ext/hash_map 71 1021 10315 104186 1248504 13433655
std::tr1::unordered_map 127 1177 11728 76864 1040697 16458108
遍历，单位us 100 1K 10K 100K 1M 10M
std::map 9 70 644 5401 53625 532577
std::ext/hash_map 24 236 2486 27212 363523 3710704
std::tr1::unordered_map 12 97 969 10421 144206 1699897
查找，单位us 100 1K 10K 100K 1M 10M
std::map 148 2038 26213 209723 2499951 28973101
std::ext/hash_map 46 461 4934 35967 457870 5254755
std::tr1::unordered_map 35 403 3692 29146 392346 4132001
删除，单位us 100 1K 10K 100K 1M 10M
std::map 230 3149 40542 362716 4114198 48995221
std::ext/hash_map 55 545 5739 65101 642365 7980524
std::tr1::unordered_map 62 674 6363 68268 705815 8129359
附录：贴上源代码
说明：与测试程序稍有区别，这里的源码里没有MD5相关的代码以确保其他人能比较方便的直接拿去编译运行。
如有错误还请跟帖指出，非常感谢。

#include   <iostream>
#include   <string>
#include   <sstream>
#include   <list>
#include   <map>
#include   <sys/time.h>
#include   <ext/hash_map>
#include   <tr1/unordered_map>
#include   <tr1/unordered_set>

namespace   zl
{  //{{{
struct   equal_to
{
bool   operator  ()(  const   char  *  s1  ,  const   char  *  s2  )  const
{
return   strcmp  (  s1 ,  s2  ) == 0;
}
};
struct   hash_string
:  public   std  ::  unary_function <  std  :: string  ,  std ::  size_t  >
{
std  :: size_t
operator  ()( const  std ::  string  &  __s  )  const
#ifdef   __linux__
{  return   std  ::  tr1 ::  Fnv_hash  <>:: hash  (  __s .  data  (),  __s  .  length ()); }
#else
{  return   std  ::  tr1 ::  _Fnv_hash  <>:: hash  (  __s .  data  (),  __s  .  length ()); }
#endif
};

struct   hash_charptr
:  public   std  ::  unary_function <  const   char  *,  std ::  size_t  >
{
std  :: size_t
operator  ()( const  char *  __s  )  const
#ifdef   __linux__
{  return   std  ::  tr1 ::  Fnv_hash  <>:: hash  (  __s ,  strlen  ( __s  )); }
#else
{  return   std  ::  tr1 ::  _Fnv_hash  <>:: hash  (  __s ,  strlen  ( __s  )); }
#endif
};
}  //}}}

typedef   std  ::  list <  std  :: string  >  string_list ;
typedef   std  ::  map <  std  :: string  ,  int >  string_map  ;
typedef   __gnu_cxx  ::  hash_map <  std  :: string  ,  int ,  zl  :: hash_string  >  string_hash_map ;
typedef   std  ::  tr1 ::  unordered_map  < std  ::  string ,  int  >  string_unordered_map  ;

void   fill_list  (  string_list &  slist  ,  size_t  count );
uint64_t   current_usec  ();

int   main  (  int   argc  ,  char  *  argv [] )
{
if  (  argc  != 2 &&  argc  != 3)
{
fprintf  ( stderr  ,  “Usage:%s test_count rehash\n”  ,  argv  [0]);
fprintf  ( stderr  ,  “For example:%s 10000 rehash\n”  ,  argv  [0]);
return  -1;
}

size_t   count  =  atoi  (  argv [1]);
bool   rehash  =  false  ;
if  (  argc  == 3)
{
rehash  =  true  ;
}

string_map   smap  ;
string_hash_map   shash_map  ;
string_unordered_map   sunordered_map  ;

if  (  rehash  )
{
sunordered_map  . rehash  (  count );
}

string_list   slist  ;
fill_list (  slist  ,  count  );

uint64_t   start  = 0;
uint64_t   end  = 0;

uint64_t   map_insert_us  = 0;
uint64_t   hash_map_insert_us  = 0;
uint64_t   unordered_map_insert_us  = 0;

uint64_t   map_traverse_us  = 0;
uint64_t   hash_map_traverse_us  = 0;
uint64_t   unordered_map_traverse_us  = 0;

uint64_t   map_find_us  = 0;
uint64_t   hash_map_find_us  = 0;
uint64_t   unordered_map_find_us  = 0;

uint64_t   map_delete_us  = 0;
uint64_t   hash_map_delete_us  = 0;
uint64_t   unordered_map_delete_us  = 0;



// Insert test
{  //{{{
string_list  :: iterator  it (  slist  . begin  ());
string_list  :: iterator  ite (  slist  . end  ());

//map insert
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
smap  [* it  ] =  i ;
}
end  =  current_usec  ();
map_insert_us  =  end  -  start ;

//hash_map insert
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
shash_map  [* it  ] =  i ;
}
end  =  current_usec  ();
hash_map_insert_us  =  end  -  start ;

//unordered_map insert
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
sunordered_map  [* it  ] =  i ;
}
end  =  current_usec  ();
unordered_map_insert_us  =  end  -  start ;
}  //}}}

// Traverse test
{  //{{{
//map traverse
{
string_map  :: iterator  it (  smap  . begin  ());
string_map  :: iterator  ite (  smap  . end  ());
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it )
{
i  ++;
}
end  =  current_usec  ();
map_traverse_us  =  end  -  start ;
}

//hash_map traverse
{
string_hash_map  :: iterator  it (  shash_map  . begin  ());
string_hash_map  :: iterator  ite (  shash_map  . end  ());
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it )
{
i  ++;
}
end  =  current_usec  ();
hash_map_traverse_us  =  end  -  start ;
}

//unordered_map traverse
{
string_unordered_map  :: iterator  it (  sunordered_map  . begin  ());
string_unordered_map  :: iterator  ite (  sunordered_map  . end  ());
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it )
{
i  ++;
}
end  =  current_usec  ();
unordered_map_traverse_us  =  end  -  start ;
}
}  //}}}

// Find test
{  //{{{
string_list  :: iterator  it (  slist  . begin  ());
string_list  :: iterator  ite (  slist  . end  ());

//map find
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
smap  [* it  ] =  i ;
}
end  =  current_usec  ();
map_find_us  =  end  -  start ;

//hash_map find
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
shash_map  [* it  ] =  i ;
}
end  =  current_usec  ();
hash_map_find_us  =  end  -  start ;

//unordered_map find
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
sunordered_map  [* it  ] =  i ;
}
end  =  current_usec  ();
unordered_map_find_us  =  end  -  start ;
}  //}}}

// Delete test
{  //{{{
string_list  :: iterator  it (  slist  . begin  ());
string_list  :: iterator  ite (  slist  . end  ());

//map delete
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
smap  . erase  (*  it );
}
end  =  current_usec  ();
map_delete_us  =  end  -  start ;

//hash_map delete
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
shash_map  . erase  (*  it );
}
end  =  current_usec  ();
hash_map_delete_us  =  end  -  start ;

//unordered_map delete
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
sunordered_map  . erase  (*  it );
}
end  =  current_usec  ();
unordered_map_delete_us  =  end  -  start ;
}  //}}}

//stat output
std ::  cout  <<  “          insert, count “  <<  count  <<  std  :: endl  ;
std ::  cout  <<  “               std::map “  <<  map_insert_us  <<  ” us\n”  ;
std ::  cout  <<  “      std::ext/hash_map “  <<  hash_map_insert_us  <<  ” us\n”  ;
std ::  cout  <<  “std::tr1::unordered_map “  <<  unordered_map_insert_us  <<  ” us\n”  ;

std ::  cout  <<  “\n”  ;
std ::  cout  <<  “        traverse, count “  <<  count  <<  std  :: endl  ;
std ::  cout  <<  “               std::map “  <<  map_traverse_us  <<  ” us\n”  ;
std ::  cout  <<  “      std::ext/hash_map “  <<  hash_map_traverse_us  <<  ” us\n”  ;
std ::  cout  <<  “std::tr1::unordered_map “  <<  unordered_map_traverse_us  <<  ” us\n” ;

std ::  cout  <<  “\n”  ;
std ::  cout  <<  “            find, count “  <<  count  <<  std  :: endl  ;
std ::  cout  <<  “               std::map “  <<  map_find_us  <<  ” us\n”  ;
std ::  cout  <<  “      std::ext/hash_map “  <<  hash_map_find_us  <<  ” us\n”  ;
std ::  cout  <<  “std::tr1::unordered_map “  <<  unordered_map_find_us  <<  ” us\n”  ;

std ::  cout  <<  “\n”  ;
std ::  cout  <<  “          delete, count “  <<  count  <<  std  :: endl  ;
std ::  cout  <<  “               std::map “  <<  map_delete_us  <<  ” us\n”  ;
std ::  cout  <<  “      std::ext/hash_map “  <<  hash_map_delete_us  <<  ” us\n”  ;
std ::  cout  <<  “std::tr1::unordered_map “  <<  unordered_map_delete_us  <<  ” us\n”  ;

return  0;
}

void   fill_list  (  string_list &  slist  ,  size_t  count )
{
for  (  size_t   i  = 0;  i  <  count  ; ++ i  )
{
std  :: ostringstream  oss ;
oss  <<  i  ;
//slist.push_back(MD5::hex(oss.str().c_str(), oss.str().length()));
slist  . push_back  (  oss .  str  ()); //
}
}


uint64_t   current_usec  ()
{
struct   timeval   tv  ;
gettimeofday ( &  tv  ,  NULL  );
return   tv  . tv_sec  * 1000 * 1000 +  tv .  tv_usec  ;
}
2012年1月8日  | by zieckey  | 标签: hash_map, map, STL, unordered_map, 关联容器, 性能比较, 用法示例

by zieckey

map hash_map unordered_map 性能测试
先给结论：
1. std::tr1::unordered_map 与 std::ext/hash_map
相对而言，遍历、查找等操作unordered_map要优于hash_map。hash_map的删除操作稍稍优于unordered_map。插入操作随着数据量的变化，10000以内时hash_map稍稍占优，10000以上的数据时，unordered_map 要稍稍快于hash_map。
2. std::tr1::unordered_map 与 std::map
unordered_map在元素个数小于1000的时候，遍历性能稍稍低于map 25%左右，一旦大于元素个数大于1000，起遍历所花时间较map多2~3倍。
因此，当我们遍历较多时，请考虑使用map而不是unordered_map。另外，当我们需要一个有序的关联容器的时候，我们必须选择map，因为 unordered_map 内部元素不是有序的，这一点从名字都可以看出来。
测试条件：
gcc version 4.2.1 20070719  [FreeBSD]
FreeBSD  7.2-RELEASE #0: Fri May  1 07:18:07 UTC 2009     root@driscoll.cse.buffalo.edu:/usr/obj/usr/src/sys/GENERIC  amd64
Intel(R) Xeon(R) CPU           E5620  @ 2.40GHz 16核
测试程序说明：
先准备好n个字符串随机的MD5字符串做为key，然后分别对3个容器进行插入、遍历、查找、删除操作。
例如，n=100的时候，插入是指插入100个随机MD5 key；遍历是指对容器遍历一次；查找是指分别对这个100个随机的MD5 key做查找操作（即查找100次）；删除是指挨个删除这个100个随机MD5 key。
测试数据如下表：
插入，单位us 100 1K 10K 100K 1M 10M
std::map 272 3485 43767 538052 3938154 45533490
std::ext/hash_map 71 1021 10315 104186 1248504 13433655
std::tr1::unordered_map 127 1177 11728 76864 1040697 16458108
遍历，单位us 100 1K 10K 100K 1M 10M
std::map 9 70 644 5401 53625 532577
std::ext/hash_map 24 236 2486 27212 363523 3710704
std::tr1::unordered_map 12 97 969 10421 144206 1699897
查找，单位us 100 1K 10K 100K 1M 10M
std::map 148 2038 26213 209723 2499951 28973101
std::ext/hash_map 46 461 4934 35967 457870 5254755
std::tr1::unordered_map 35 403 3692 29146 392346 4132001
删除，单位us 100 1K 10K 100K 1M 10M
std::map 230 3149 40542 362716 4114198 48995221
std::ext/hash_map 55 545 5739 65101 642365 7980524
std::tr1::unordered_map 62 674 6363 68268 705815 8129359
附录：贴上源代码
说明：与测试程序稍有区别，这里的源码里没有MD5相关的代码以确保其他人能比较方便的直接拿去编译运行。
如有错误还请跟帖指出，非常感谢。

#include   <iostream>
#include   <string>
#include   <sstream>
#include   <list>
#include   <map>
#include   <sys/time.h>
#include   <ext/hash_map>
#include   <tr1/unordered_map>
#include   <tr1/unordered_set>

namespace   zl
{  //{{{
struct   equal_to
{
bool   operator  ()(  const   char  *  s1  ,  const   char  *  s2  )  const
{
return   strcmp  (  s1 ,  s2  ) == 0;
}
};
struct   hash_string
:  public   std  ::  unary_function <  std  :: string  ,  std ::  size_t  >
{
std  :: size_t
operator  ()( const  std ::  string  &  __s  )  const
#ifdef   __linux__
{  return   std  ::  tr1 ::  Fnv_hash  <>:: hash  (  __s .  data  (),  __s  .  length ()); }
#else
{  return   std  ::  tr1 ::  _Fnv_hash  <>:: hash  (  __s .  data  (),  __s  .  length ()); }
#endif
};

struct   hash_charptr
:  public   std  ::  unary_function <  const   char  *,  std ::  size_t  >
{
std  :: size_t
operator  ()( const  char *  __s  )  const
#ifdef   __linux__
{  return   std  ::  tr1 ::  Fnv_hash  <>:: hash  (  __s ,  strlen  ( __s  )); }
#else
{  return   std  ::  tr1 ::  _Fnv_hash  <>:: hash  (  __s ,  strlen  ( __s  )); }
#endif
};
}  //}}}

typedef   std  ::  list <  std  :: string  >  string_list ;
typedef   std  ::  map <  std  :: string  ,  int >  string_map  ;
typedef   __gnu_cxx  ::  hash_map <  std  :: string  ,  int ,  zl  :: hash_string  >  string_hash_map ;
typedef   std  ::  tr1 ::  unordered_map  < std  ::  string ,  int  >  string_unordered_map  ;

void   fill_list  (  string_list &  slist  ,  size_t  count );
uint64_t   current_usec  ();

int   main  (  int   argc  ,  char  *  argv [] )
{
if  (  argc  != 2 &&  argc  != 3)
{
fprintf  ( stderr  ,  “Usage:%s test_count rehash\n”  ,  argv  [0]);
fprintf  ( stderr  ,  “For example:%s 10000 rehash\n”  ,  argv  [0]);
return  -1;
}

size_t   count  =  atoi  (  argv [1]);
bool   rehash  =  false  ;
if  (  argc  == 3)
{
rehash  =  true  ;
}

string_map   smap  ;
string_hash_map   shash_map  ;
string_unordered_map   sunordered_map  ;

if  (  rehash  )
{
sunordered_map  . rehash  (  count );
}

string_list   slist  ;
fill_list (  slist  ,  count  );

uint64_t   start  = 0;
uint64_t   end  = 0;

uint64_t   map_insert_us  = 0;
uint64_t   hash_map_insert_us  = 0;
uint64_t   unordered_map_insert_us  = 0;

uint64_t   map_traverse_us  = 0;
uint64_t   hash_map_traverse_us  = 0;
uint64_t   unordered_map_traverse_us  = 0;

uint64_t   map_find_us  = 0;
uint64_t   hash_map_find_us  = 0;
uint64_t   unordered_map_find_us  = 0;

uint64_t   map_delete_us  = 0;
uint64_t   hash_map_delete_us  = 0;
uint64_t   unordered_map_delete_us  = 0;



// Insert test
{  //{{{
string_list  :: iterator  it (  slist  . begin  ());
string_list  :: iterator  ite (  slist  . end  ());

//map insert
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
smap  [* it  ] =  i ;
}
end  =  current_usec  ();
map_insert_us  =  end  -  start ;

//hash_map insert
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
shash_map  [* it  ] =  i ;
}
end  =  current_usec  ();
hash_map_insert_us  =  end  -  start ;

//unordered_map insert
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
sunordered_map  [* it  ] =  i ;
}
end  =  current_usec  ();
unordered_map_insert_us  =  end  -  start ;
}  //}}}

// Traverse test
{  //{{{
//map traverse
{
string_map  :: iterator  it (  smap  . begin  ());
string_map  :: iterator  ite (  smap  . end  ());
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it )
{
i  ++;
}
end  =  current_usec  ();
map_traverse_us  =  end  -  start ;
}

//hash_map traverse
{
string_hash_map  :: iterator  it (  shash_map  . begin  ());
string_hash_map  :: iterator  ite (  shash_map  . end  ());
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it )
{
i  ++;
}
end  =  current_usec  ();
hash_map_traverse_us  =  end  -  start ;
}

//unordered_map traverse
{
string_unordered_map  :: iterator  it (  sunordered_map  . begin  ());
string_unordered_map  :: iterator  ite (  sunordered_map  . end  ());
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it )
{
i  ++;
}
end  =  current_usec  ();
unordered_map_traverse_us  =  end  -  start ;
}
}  //}}}

// Find test
{  //{{{
string_list  :: iterator  it (  slist  . begin  ());
string_list  :: iterator  ite (  slist  . end  ());

//map find
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
smap  [* it  ] =  i ;
}
end  =  current_usec  ();
map_find_us  =  end  -  start ;

//hash_map find
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
shash_map  [* it  ] =  i ;
}
end  =  current_usec  ();
hash_map_find_us  =  end  -  start ;

//unordered_map find
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
sunordered_map  [* it  ] =  i ;
}
end  =  current_usec  ();
unordered_map_find_us  =  end  -  start ;
}  //}}}

// Delete test
{  //{{{
string_list  :: iterator  it (  slist  . begin  ());
string_list  :: iterator  ite (  slist  . end  ());

//map delete
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
smap  . erase  (*  it );
}
end  =  current_usec  ();
map_delete_us  =  end  -  start ;

//hash_map delete
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
shash_map  . erase  (*  it );
}
end  =  current_usec  ();
hash_map_delete_us  =  end  -  start ;

//unordered_map delete
it  =  slist  .  begin ();
start  =  current_usec  ();
for  ( int  i  = 0;  it  !=  ite  ; ++  it , ++  i  )
{
sunordered_map  . erase  (*  it );
}
end  =  current_usec  ();
unordered_map_delete_us  =  end  -  start ;
}  //}}}

//stat output
std ::  cout  <<  “          insert, count “  <<  count  <<  std  :: endl  ;
std ::  cout  <<  “               std::map “  <<  map_insert_us  <<  ” us\n”  ;
std ::  cout  <<  “      std::ext/hash_map “  <<  hash_map_insert_us  <<  ” us\n”  ;
std ::  cout  <<  “std::tr1::unordered_map “  <<  unordered_map_insert_us  <<  ” us\n”  ;

std ::  cout  <<  “\n”  ;
std ::  cout  <<  “        traverse, count “  <<  count  <<  std  :: endl  ;
std ::  cout  <<  “               std::map “  <<  map_traverse_us  <<  ” us\n”  ;
std ::  cout  <<  “      std::ext/hash_map “  <<  hash_map_traverse_us  <<  ” us\n”  ;
std ::  cout  <<  “std::tr1::unordered_map “  <<  unordered_map_traverse_us  <<  ” us\n” ;

std ::  cout  <<  “\n”  ;
std ::  cout  <<  “            find, count “  <<  count  <<  std  :: endl  ;
std ::  cout  <<  “               std::map “  <<  map_find_us  <<  ” us\n”  ;
std ::  cout  <<  “      std::ext/hash_map “  <<  hash_map_find_us  <<  ” us\n”  ;
std ::  cout  <<  “std::tr1::unordered_map “  <<  unordered_map_find_us  <<  ” us\n”  ;

std ::  cout  <<  “\n”  ;
std ::  cout  <<  “          delete, count “  <<  count  <<  std  :: endl  ;
std ::  cout  <<  “               std::map “  <<  map_delete_us  <<  ” us\n”  ;
std ::  cout  <<  “      std::ext/hash_map “  <<  hash_map_delete_us  <<  ” us\n”  ;
std ::  cout  <<  “std::tr1::unordered_map “  <<  unordered_map_delete_us  <<  ” us\n”  ;

return  0;
}

void   fill_list  (  string_list &  slist  ,  size_t  count )
{
for  (  size_t   i  = 0;  i  <  count  ; ++ i  )
{
std  :: ostringstream  oss ;
oss  <<  i  ;
//slist.push_back(MD5::hex(oss.str().c_str(), oss.str().length()));
slist  . push_back  (  oss .  str  ()); //
}
}


uint64_t   current_usec  ()
{
struct   timeval   tv  ;
gettimeofday ( &  tv  ,  NULL  );
return   tv  . tv_sec  * 1000 * 1000 +  tv .  tv_usec  ;
}
kmcfly
关注
专栏目录
map hash_map unordered_map 性能测试
程序员黄老师的精品课！
02-28 618
测试环境： 测试工具：      Microsoft Visual Studio Enterprise 2015   版本 14.0.25431.01 Update 3     Microsoft .NET Framework      版本 4.6.01586测试代码： 插入操作#include &lt;stdio.h&gt; #include &lt;windows.h&gt; #inc...
C++ unordered_map 和 hash_map的用法
weixin_39970103的博客
09-16 2195
1、C++ STL中哈希表 hash_map从头到尾详细介绍 2、C++ unordered_map unordered_map是hash_map的替代名称 最初的 C++ 标准库中没有类似 hash_map 的实现，但不同实现者自己提供了非标准的 hash_map。 因为这些实现不是遵循标准编写的，所以它们在功能和性能保证方面都有细微差别。 从 C++ 11 开始，hash_map 实现已被...
c++ map hash_map unordered_map 比较
ochonglangzheo的专栏
12-27 1523
map hash_map unordered_map 性能测试  by zieckey 测试条件： gcc version 4.2.1 20070719  [FreeBSD] FreeBSD  7.2-RELEASE #0: Fri May  1 07:18:07 UTC 2009     root@driscoll.cse.buffalo.ed
C++ :unordered_map性能测试
qq_37120714的博客
10-15 842
1.环境：vs2017编译器 ->Release模式 2.系统内存：8G ,Windows10 专业版 class FirstCPPCls { private: string serviceId; string systemId; string subSystemId; string appVersion; string companyId; string clusterName; public: FirstCPPCls(void) {} ~FirstCPPCls(void) {}
关于map、hash_map 和 unordered_map 的简单性能测试
耍宝王专栏
09-13 2505
测试环境： DELL Latitude D610 CPU:Pentium-M 1.73 GHz 内存：2.00GB OS:Windows 2003 开发环境: Visual Studio 2010 编译参数：/MD /Ox /Ot /W3 /D "_CRT_SECUR
unordered_set，unordered_map中自定义hashfunction
A_Bo的博客
02-22 3740
写在前面 在c++11新标准中引入了unordered_set以及unordered_map，其背后是根据hash实现，而set、map等背后是根据RB_tree实现，在实现hash时，需要将数据转换为对应的hash码，放入对应的bucket中，所以这里的hash function是至关重要的 简单的hash function 我们可以通过hash_function()函数得到对应的hash...
map、hash_map、unordered_map
K123966的博客
03-24 448
map、hash_map、unordered_map的区别： 相同点： 1.都是关联容器，关联容器将值与键关联在一起，并使用键来查找值，例如，值可以是表示雇员信息（如姓名、地址）的结构，而键可以是唯一的员工编号。为获取雇员信息，为获取雇员信息，程序将使用键查找雇员结构。2.键是唯一的。 不同点： map是有序关联容器，是经过排序的，这让它们能够使用表示“小于”概念的比较谓词。其底层是基于树结构实现...
初识C++之unordered_map与unordered_set
Masquerena114514的博客
04-07 2225
本文主要讲述了通过对哈希桶的改造，使得unordered_set和unordered_map能够对同一个哈希桶进行封装并模拟实现
map, hash_map,unordered_map与性能测试
williamwyx的专栏
03-26 611
转自：http://blog.sina.com.cn/s/blog_59b6af690100xy0z.html Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红
unordered_map详解和性能分析
热门推荐
上官宏竹的专栏
03-12 2万+
std::unordered_map是C++标准库中的一个关联容器，它可以存储一组键值对，并且支持快速的查找、插入和删除操作。class Ty,std::hash是一个模板类，它接受一个类型参数T，用于指定需要哈希的对象类型。还提供了一个函数调用运算符（operator()），用于计算对象的哈希值。perator()接受一个常量引用key，用于指定需要计算哈希值的对象。它返回一个类型的哈希值，表示对象在哈希表中的桶位置。实现一个哈希函数。
C++ std map unordered_map hash_map 的查找性能测试代码及结果
Echo的博客
11-25 1876
测试结果 Release模式下： 查找效率：unordered_map ≈ hash_map > map std::map 的效率远小于 unordered_map 和 hash_map Debug模式下： 1. 查找效率：hash_map > unordered_map > map 2. 随着容量的增加，hash_map, unordered_map的查找效率有所降低，但浮动不大毕竟是常量级别。map的效率直线下降.... 详细数据见本文下方的 [测试过程记录](测试过程记录)
C++ STL unordered_map和map的使用和性能分析
zhc_24的博客
05-10 1万+
unordered_map是C++ Boost库中的内容，这里的unordered翻译成“无序”。但它并不是完全的“无序”的概念，而是散列式的存储方式。 unordered库提供了两个散列映射类，unordered_map和unordered_multimap。 它们用散列表代替了二叉树的实现，模板参数多了散列计算函数，比较谓词使用equal_to&lt;&gt;。 看到这里，我们就应该明白，...
测试std::map与boost::unordered_map性能
XiaoWhy的专栏
01-12 517
测试方法：加载文件，将数据分别插入到std::map和boost::unordered_map中，分别保存string作为key和int作为key的map数据，计算插入时间，根据列表分别在对应的map中查找一次所有的key值，计算查找耗时： 测试结果：插入耗时boost::unordered_map是std map的一半左右，查找耗时是std map的1/3左右 测试代码： #include <boost/unordered/unordered_map.hpp> #include &lt
map unordered_map hash_map的查找性能测试
papaya的博客
10-30 2519
结论如下： Release模式下： 1. 容量为10的时候，查找效率：map > unordered_map > hash_map 2. 容量为100的时候，查找效率：map = unordered_map > hash_map 3. 容量为1000的时候，查找效率：unordered_map > hash_map > 4倍map 4. 容量为1万的时候，查...
[原创]STL容器map和unordered_map性能，创建，插入，随机访问速度对比！
carlclouder的博客
09-06 1600
测试map和unordered_map，采用1亿次随机访问，分别在数据量10~1000万不同情况测试，生成时间和随机访问时间； 平台：win10，vs2019，c++14，编译，启动优化 结论： 1、unordered_map在任何情况下都要比map的随机访问速度更快，5倍以上； 2、unordered_map在100万数据量以下要比map的随机插入速度快，如果单个保存的数据结构较大，这一速度会进一步降低； 3、unordered_map会比map占用更多的内存； 元素个数 | 访问次数 | map
std::map std::unordered_map 性能测试
uniqs 的博客
03-16 4952
先上图：win7 vs2013 debug版本： win7 vs2013 release版本： centos7.0 gcc4.8.5 -g  （我是在虚拟机里，内存比较少，所以只分配了两万个）： 从测试结果可以看出：std::unordered_map插入、删除的性能会比std::map稍差一点，但是查找速度std::unordered_map和std::map的比例基本
map unordered_map 性能对比
qixiang2013的专栏
09-15 3349
结论如下： Release模式下： 1. 容量为10的时候，查找效率：map > unordered_map > hash_map 2. 容量为100的时候，查找效率：map = unordered_map > hash_map 3. 容量为1000的时候，查找效率：unordered_map > hash_map > 4倍map 4. 容量为1万的时候，查找效率：hash_map > unordered_map > 4倍map 5. 容量为10万的时候
C++ unordered_map和map对比
TABE_的博客
03-10 2666
需要引入的头文件不同 map: #include < map > unordered_map: #include < unordered_map > 内部实现机理不同 map： map内部实现了一个红黑树（红黑树是非严格平衡二叉搜索树，而AVL是严格平衡二叉搜索树），红黑树具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素。因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行的操作。map中的元素是按照二叉搜索树（
hash_map就是unordered_map吗
最新发布
09-13
当数据量逐渐增大时，hash_map的插入性能更好，而标准库的unordered_map的性能与hash_map相差不大，只是略逊一些。 所以，hash_map和unordered_map在实际上是不同的容器。unordered_map是C++标准库中的一个无序关联...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值