哈希表及其在STL中的实现

最新推荐文章于 2024-07-01 21:21:55 发布
最新推荐文章于 2024-07-01 21:21:55 发布
阅读量1.7k 收藏 11
点赞数 4
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39010744/article/details/108264158
版权

最近刷题遇到哈希表（散列表）的应用，对这方面不太了解的话用起来还是有点茫，首先总结一下什么是哈希表。

散列表查找（哈希表）概述

        一般用来存储数据的顺序表我们是比较熟悉的，存储时依次存入，但是要查找顺序表中某个关键字的记录，就需要从表头依次查找。比如日常用的数组或链表中，要知道某个数据在数组或链表中的下表或者第几个位置需要遍历数组找到该数据，才能得到查询结果，这样查找的时间复杂度较高。因此能不能能不遍历直接查找呢？当然是可以的，这就用到我们所要讲的散列技术了。

        散列技术是在记录的存储位置和它的关键字之间简历一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key)。查找是，根据这个这个对应关系就可轻松找到关键字key的映射f(key)。这种对应关系f成为散列函数，又成为哈希函数。采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为散列表或哈希（Hash table）表。

散列表（哈希表）的构造

        就像数学中的映射关系，不同的x值通过函数运算可能得到相同值，这样的现象称为冲突。给定一组数据，进行存储时需要构造一个好的散列函数，尽量避免产生冲突。好的散列函数一般有两个原则：计算简单、散列地址均匀。

  •  若一个好的散列函数可以让说有的关键字都不产生冲突，但是这个算法复杂，则违背了散列技术想要节省查找时间的初衷，这对于频繁查找来说会大大降低查找效率。
  • 尽量让散列地址均匀分布在存储空间中可以保证存储空间的有效利用，并减少为处理冲突而耗费时间

具体的构造方法包括：

  1. 直接定址法
  2. 数字分析法
  3. 平方取中法
  4. 折叠法
  5. 除留余数法
  6. 随机数法
  7. 开放定址法
  8. 链地址法
  9. 再散列函数法
  10. 公共溢出区法

上述方法的详细说明均可在《大话数据结构》一书中找到，或者看下面这位博主写得非常详细：

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/weixin_38169413/article/details/81612307

总的来说就是一些构造数据映射关系的方法。若还是不太理解构造散列函数，再此我就自己的理解简单举个例子，看如下数据：

对关键字集合{12，67，56，16，25，37，22，29，15，47，48，34}，表长为m=12。

对上述数据用开放定址法如何构造散列函数呢？首先要知道开放定址法的公式：

f_{i}(key)=(f(key)+d_{i})MOD m (d_{i}=1,2,3,......m-1)

MOD就是取模（求余数）的意思。利用该公式来计算：

f(12)=12MOD12=0；f(67)=67MOD12=7;......前五个数字{12，67，56，16，25}都没有冲突的散列地址，如下表：

下标01234567891011
关键字1225  16  6756   

计算key=37时，发现f(37)=1，此时就与25所在的位置冲突。于是我们应用上面的公式f(37)=(f(37)+1) mod 12=2。于是将37存入下标为2的位置。通过上述方法最终得到下表：

下标01234567891011
关键字122537151629486756342247

通过该例子应该了解基本的散列函数构造思想了，不同的构造方法效率、性能都不同。

通过散列表查找时，通过散列函数和关键字便可很容易得到关键字对应的地址。

哈希表的C++实现

        好了，哈希表的基本概念了解清楚了，进入重点：STL中实现的容器．

        我们平常用到的哈希表通常不是自己进行存储，用的最多的是已知某对应关系，然后直到某关键字值，希望立马能知道与其相关联的数据值。哈希表在STL中存在多种实现。从网上搜索会发现有map、unordered_map、unordered_multimap等容器均可实现哈希表的相似功能。功能上相似，但是使用上又不尽相同。接下来我将分别对几种容器进行讲解，最后进行比较。

STL中的map

        map是STL中的一个关联容器，它提供一对一的数据处理能力，从而方便我们处理一对一的数据，为编程提供快速通道。而哈希表是一种基于键值映射的快速搜索的数据结构，注意两者的关联和区别。map以模板(泛型)方式实现，可以存储任意类型包括使用者自定义的数据类型。map中的第一个数据称为关键字（key），每个关键字只能在map中出现一次。第二个称为该关键字的值。map内部自建一颗红黑树(一 种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的。在红黑树上做查找、插入、删除操作的时间复杂度为O(logN)。

1、使用map

接下来说一下在编程中应该如何使用map：

  • 需要包含map类所在的头文件,注意STL头文件没有扩展名
#include <map>
  • 要创建map模板对象，可使用<type,type>表示法来指出关键字和对应值的类型。
std:map<int, string> mymap;    //定义一个空的map对象mymap
std::map<int, string> mymap2(mymap);    //创建了mymap的副本mymap2

这样便定义了一个map模板对象。

2、map的插入、删除、遍历及其他常用操作函数

  • map的插入

（1）使用insert(pair<type,type>(value,value))函数插入数据。返回值是一个pair结构，其中第一个元素是一个迭代器，第二个元素是一个bool类型，根据以上结果：如果原来的map中不含有插入的元素，则bool为true，迭代器指向插入的元素；如果map中已经含有插入的元素了，则bool为false，返回的迭代器指向对应的map中已经存在的元素.

std::pair主要的作用是将两个数据组合成一个数据，两个数据可以是同一类型或者不同类型。C++标准程序库中凡是“必须返回两个值”的函数， 也都会利用pair对象。class pair可以将两个值视为一个单元。容器类别map和multimap就是使用pairs来管理其健值/实值(key/value)的成对元素。两个pairs互相比较时， 第一个元素具有较高的优先级.。pair实质上是一个结构体，其主要的两个成员变量是first和second，这两个变量可以直接使用。

mymap.insert(pair<int,string>(1,"aaa"));

（2）使用insert(make_pair<make_type,type>(value,value))函数插入数据。与第一种方法类似，区别在于make_pair的用法无需写出型别， 就可以生成一个pair对象。

mymap.insert(make_pair(1,"aaa"));

（3）使用value_type方法。先说说什么是value_type，每个STL中的类都有value_type这种东西，通俗的说value_type 就是stl容器盛装的数据的数据类型。比如说：

vector<double> myvec;

vector::value_type x;

上述两句代码，第一句是声明一个盛装数据类型是int的数据的vector，第二句是使用vector::value_type定义一个变量x，这个变量x实际上是double类型的，因为vector::value_type中声明的为double型。

进入正题：

mymap.insert(map<int,string>::value_type(1,"aaa"));

（4）使用[ ]数组方式插入。使用该方法时，出现重复键时，会覆盖掉之前的键对值。

mymap[1]="aaa";

  • map的其他操作操作函数

函数举例功能（返回）备注
begin()map<int, string>::iterator it=mymap.begin();返回指向第一个元素(头部)的迭代器iterator 
end()map<int, string>::iterator it=mymap.end();返回指向最后一个元素的下一个元素(末尾)的迭代器iterator 
count()int num=mymap.count(1);返回指定元素出现的次数注意，map中不存在相同元素，所以返回值只能是1或0。
empty()mymap.empty();如果map为空则返回true 
equal_range()

mymap[1]="aaa";

mymap[2]="bbb";

mymap[3]="ccc";

pair<map<int,string>::iterator,

map<int,string>::iterator> ret;

ret=mymap.equal_range(1);

返回的结果如下：

ret.first=pair<int,string>(1,"aaa");

ret.second=pair<int,string>(2,"bbb");

返回特殊条目的迭代器对,C++ STL中的一种二分查找的算法，试图在已排序的[first,last)中寻找value，它返回一对迭代器i和j，其中i是在不破坏次序的前提下，value可插入的第一个位置（亦即lower_bound），j则是在不破坏次序的前提下，value可插入的最后一个位置（亦即upper_bound），我们可把它想成是[first,last)内"与value等同"之所有元素形成的区间A，由于[fist,last)有序（sorted），所以我们知道"与value等同"之所有元素一定都相邻，于是，算法lower_bound返回区间A的第一个迭代器，算法upper_bound返回区间A的最后一个元素的下一个位置，算法equal_range则是以pair的形式将两者都返回
erase()

map<int, string>::iterator iter,nextiter;

nextiter=mymap.erase(iter);

删除一个元素，返回下一个元素的迭代器注意对于关联容器来说，如果某一个元素已经被删除，那么其对应的迭代器就失效了，不应该再被使用，否则会导致程序无定义的行为。使用删除之前的迭代器定位下一个元素
find()

map<int, string>::iterator it;

it=mymap.find(1);

用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器 
get_allocator()mymap.get_allocator();返回map的配置器 
value_comp()

mymap[1]="aaa";

mymap[2]="bbb";

mymap[3]="ccc";

map<int, string>::iterator iter1,iter2;

iter1=mymap.find(“aaa”);

iter2=mymap.find("bbb");

mymap.value_comp()(iter1,iter2);

返回1表示iter1在前，返回0表示iter2在前

其返回值是一个比较类的对象，这个类是map::value_compare，并且是map的一个内部类。返回的这个对象可以用来通过比较两个元素的value来判决它们对应的key在map的位置谁在前面谁在后面。 
key_comp() 返回比较元素key位置前后的函数 
max_size()int maxnum=mymap.max_size();返回可以容纳的最大元素个数 
rbegin()

map<int, string>::iterator iter;

iter=mymap.rbegin();

返回一个指向map尾部的逆向迭代器 
rend()

map<int, string>::iterator iter;

iter=mymap.rend();

返回一个指向map头部的逆向迭代器 
size()int num=mymap.size();返回map中元素的个数 
swap() 
mymap1.swap(mymap2)
       OR
swap(mymap1, mymap2)
swap()函数用于交换两个Map的内容，但是Map的类型必须相同，尽管大小可能会有所不同. 
lower_bound()upper_bound()  
upper_bound()   
at()mymap.at(1);

at()函数用于将引用返回给与键k关联的元素,

它返回对键值等于k的元素的关联值的引用。

 

 

clear()mymap.clear();

清空所有元素。

 

 

STL中的unorederd_map

        unordered_map与map功能相似，也是一个关联容器，其中的元素根据键来引用，而不是根据索引来引用。在内部，std::unordered_map中的元素不会根据其键值或映射值按任何特定顺序排序，而是根据其哈希值组织到桶中，以允许通过键值直接快速访问各个元素（常量的平均时间复杂度）。std::unorederd_map中的元素的键是唯一的。

        map与unordered_map的区别

        std::map对应的数据结构是红黑树。红黑树是一种近似于平衡的二叉查找树，里面的数据是有序的。在红黑树上做查找、插入、删除操作的时间复杂度为O(logN)。而std::unordered_map对应哈希表，哈希表的特点就是查找效率高，时间复杂度为常数级别O(1)， 而额外空间复杂度则要高出许多。所以对于需要高效率查询的情况，使用std::unordered_map容器，但是std::unordered_map对于迭代器遍历效率并不高。而如果对内存大小比较敏感或者数据存储要求有序的话，则可以用std::map容器。

1、使用unordered_map

接下来说一下在编程中应该如何使用unordered_map：

  • 需要包含unordered_map类所在的头文件<unordered_map>,注意STL头文件没有扩展名
#include  <unordered_map>
  • 要创建unordered_map模板对象，可使用<type,type>表示法来指出关键字和对应值的类型。
std:unordered_map<int, string> myunmap;    //定义一个空的map对象myunmap
std::unordered_map<int, string> myunmap2(myunmap);    //创建了myunmap的副本myunmap2

这样便定义了一个map模板对象。

2、unordered_map的插入、删除、遍历及其他常用操作函数

  • unordered_map的构造函数

  •  

typedef std::unordered_map<int,std::string> mynumaptype;
mynumaptype firstmap;                               //建立空容器
mynumaptype secondmap({{1,"aaa"},{2,"bbb"}});       //初始化
mynumaptype thirdmap({{3,"ccc"},{4,"ddd"}});        //初始化
mynumaptype fourthmap(secondmap);                   //复制
mynumaptype fifthmap(merge(thirdmap,fourthmap));    //移动,merge函数的作用是：将两个有序的序 
                                                    //列合并为一个有序的序列

  • unordered_map的插入

与map的插 入类似，unordered_map可采用insert()函数来插入数据：

1）使用insert(pair<type,type>(value,value))函数插入数据

2）使用insert(make_pair<make_type,type>(value,value))函数插入数据。

3）使用value_type方法

4）使用[ ]数组方式插入。使用该方法时，出现重复键时，会覆盖掉之前的键对值。

注意：const std::unordered_map 不能使用 operator[] 操作！！！！

  • unordered_map的其他操作操作函数

函数举例功能（返回）备注
begin()unordered_map<int, string>::iterator it=myunmap.begin();返回指向第一个元素(头部)的迭代器iterator 
end()unordered_map<int, string>::iterator it=myunmap.end();返回指向最后一个元素的下一个元素(末尾)的迭代器iterator 
count()int num=myunmap.count(1);返回指定元素出现的次数注意，map中不存在相同元素，所以返回值只能是1或0。
empty()myunmap.empty();如果map为空则返回true 
equal_range()

myunmap[1]="aaa";

myunmap[2]="bbb";

myunmap[3]="ccc";

pair<unordered_map<int,string>::iterator,

unordered_map<int,string>::iterator> ret;

ret=myunmap.equal_range(1);

返回的结果如下：

ret.first=pair<int,string>(1,"aaa");

ret.second=pair<int,string>(2,"bbb");

返回特殊条目的迭代器对,C++ STL中的一种二分查找的算法，试图在已排序的[first,last)中寻找value，它返回一对迭代器i和j，其中i是在不破坏次序的前提下，value可插入的第一个位置（亦即lower_bound），j则是在不破坏次序的前提下，value可插入的最后一个位置（亦即upper_bound），我们可把它想成是[first,last)内"与value等同"之所有元素形成的区间A，由于[fist,last)有序（sorted），所以我们知道"与value等同"之所有元素一定都相邻，于是，算法lower_bound返回区间A的第一个迭代器，算法upper_bound返回区间A的最后一个元素的下一个位置，算法equal_range则是以pair的形式将两者都返回
iterator erase (const_iterator position);//根据元素位置
 

unordered_map<int, string>::iterator iter,nextiter;

nextiter=myunmap.erase(iter);

删除一个元素，返回下一个元素的迭代器注意对于关联容器来说，如果某一个元素已经被删除，那么其对应的迭代器就失效了，不应该再被使用，否则会导致程序无定义的行为。使用删除之前的迭代器定位下一个元素
size_type erase (const key_type& k);//根据元素的键
 

 

int num=myunmap.erase(1);

返回被删除元素的数目，此处为1 
find()

unordered_map<int, string>::iterator it;

it=myunmap.find(1);

用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器 
get_allocator()myunmap.get_allocator();返回map的配置器 
value_comp()

myunmap[1]="aaa";

myunmap[2]="bbb";

myunmap[3]="ccc";

unordered_map<int, string>::iterator iter1,iter2;

iter1=myunmap.find(“aaa”);

iter2=myunmap.find("bbb");

myunmap.value_comp()(iter1,iter2);

返回1表示iter1在前，返回0表示iter2在前

其返回值是一个比较类的对象，这个类是map::value_compare，并且是map的一个内部类。返回的这个对象可以用来通过比较两个元素的value来判决它们对应的key在map的位置谁在前面谁在后面。 
key_comp() 返回比较元素key位置前后的函数 
max_size()int maxnum=myunmap.max_size();返回可以容纳的最大元素个数 
rbegin()

map<int, string>::iterator iter;

iter=mymap.rbegin();

返回一个指向map尾部的逆向迭代器 
rend()

unordered_map<int, string>::iterator iter;

iter=mymap.rend();

返回一个指向map头部的逆向迭代器 
size()int num=myunmap.size();返回map中元素的个数 
swap() 
myunmap1.swap(myunmap2)
       OR
swap(myunmap1, myunmap2)
swap()函数用于交换两个Map的内容，但是Map的类型必须相同，尽管大小可能会有所不同. 
map::lower_bound(key): 返回map中第一个大于或等于key的迭代器指针不小于
map::upper_bound(key) 返回map中第一个大于key的迭代器指针大于
at()myunmap.at(1);如果 k 匹配容器中某个元素的键，则该函数返回该映射值的引用。
如果 k 与容器中任何元素的键都不匹配，则该函数将抛出 out_of_range 异常。

 

 

clear()myunmap.clear();

清空所有元素。

 

const_iterator cbegin() const noexcept;myunmap.cbegin();返回一个常量迭代器，指向第一个元素

 

const_iterator cend() const noexcept;myunmap.cend();返回一个常量迭代器，指向尾后元素

 

 

 

STL中的multimap

有了上述两个容器的学习，multimap就很好理解了。multimap容器保存的是有序的键/值对，但是可以保存重复的元素。multimap中会出现具有相同键值的元素序列。multimap大部分成员函数的使用方式和map相同。因为重复键的原因，multimap有一些函数的使用方式和map有一些区别。
1、访问元素的区别
multimap 不支持下标运算符，因为键并不能确定一个唯一元素。和 map 相似，multimap 也不能使用 at() 函数。

find函数

multimap 的成员函数 find() 可以返回一个键和参数匹配的元素的迭代器。例如：

std::multimap<std::string, size_t> people {{"Ann",25},{"Bill", 46}, {"Jack", 77}, {"Jack", 32},{"Jill", 32}, {"Ann", 35} };
std::string name {"Bill"};
auto iter = people.find(name);
if (iter ! = std::end (people))
    std::cout << name << " is " << iter->second << std::endl;
iter = people.find ("Ann");
if (iter != std::end(people))
    std::cout << iter->first << " is " << iter->second <<std::endl;

如果没有找到键，会返回一个结束迭代器，所以我们应该总是对返回值进行检查。第一个 find() 调用的参数是一个键对象，因为这个键是存在的，所以输出语句可以执行。第二个 find() 调用的参数是一个字符串常量，它说明参数不需要和键是相同的类型。对容器来说，可以用任何值或对象作为参数，只要可以用函数对象将它们和键进行比较。最后一条输出语句也可以执行，因为有等于 "Ann" 的键。事实上，这里有两个等于 "Ann" 的键，你可能也会得到不同的运行结果。 

count函数

通过调用 multimap 的成员函数 count() 可以知道有多少个元素的键和给定的键相同。

erase函数

multimap 的成员函数 erase() 有 3 个版本：

  1. 以待删除元素的迭代器作为参数，这个函数没有返回值；
  2. 以一个键作为参数，它会删除容器中所有含这个键的元素，返回容器中被移除元素的个数；
  3. 接受两个迭代器参数，它们指定了容器中的一段元素，这个范围内的所有元素都会被删除，这个函数返回的迭代器指向最后一个被删除元素的后一个位置。

  

到这基本对哈希表这个数据结构以及STL中三种容器的实现基本有了了解，至少基本的使用是不成问题了。其实还有很多内容之后再补充吧！ 

参考文章：https://blog.csdn.net/qq_28584889/article/details/83855734#3.%20multimap%E5%AE%B9%E5%99%A8

                  https://blog.csdn.net/sevenjoin/article/details/81943864 

 

 
悠悠球不会转
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STL hashtable的底层实现总结
Janway-Win
04-30 2502
一、hashtable概述 hashtable在C++的STL里占据着比较重要的一席之地。其中的hash_set、hash_map、hash_multiset、hash_multimap四个关联容器都是以hashtable为底层实现方法（技巧）。应该说，上述的四个关联式容器提供的API都是对hashtable原生态API的高层封装，因为hashtable本身都提供了它们所需要的基础API。 如果要...
STL之hashtable实现
duziliulang123的博客
10-18 362
#ifndef __HASH_FUN_H #define __HASH_FUN_H template struct __hash{}; inline size_t __stl_hash_string(const char* s) { unsigned long h = 0; for (; *s; ++s) h = 5 * h + *s; return size_t(h); } te
私房STL之Hashtable
lionzl的专栏
02-27 600
私房STL之Hashtable 2 条回复 一句话之Hashtable：哈希表（散列表）能通过键值对数据进行访问的数据结构；其在C++0X标准中未出现，可能是考虑到哈希表效率低下，出于其广泛用于工程中，C++11将其纳入了标准库。C++11的新特性：http://en.wikipedia.org/wiki/C%2B%2B11，C++11中哈希表的说明：http://en.wikiped
C++ STL 中哈希表的详细用法
最新发布
TheJustice_的博客
07-01 869
C++ STL 中的和提供了强大的哈希表功能，能够高效地进行插入、删除和查找操作。理解其用法和注意事项，能够帮助我们在实际开发中更好地利用这些容器。
STL源码剖析之哈希表 hashtable【2013.12.06】
木心[ mx1024 ] 欢迎
12-06 3475
STL源码剖析之哈希表 hashtable【2013.12.06】 欢迎加入我们的QQ群，无论你是否工作，学生，只要有c / vc / c++ 编程经验，就来吧！158427611  哈希表，一种键值对用的关系。具有关联性。 也称散列表，主要是通过特殊算法建立值和键的关系，然后根据键值对应存储和搜索。 因为是键值对应的关系，所以再键的存储上面，会出现一种【碰撞】问题，即
【STL源码剖析】第五章 关联式容器 之 hashtable底层实现
stt2019
06-16 514
hashtable二叉搜索树具有对视平均时间的表现，但这种的表现构造在一个假设上：输入数据有足够的随机性。这一节介绍一种名为hastable（散列表）的数据结构，这种结构在插入、删除、搜寻等操作上也具有“常数平均时间”的表现，而这种表现是以统计为基础的，不需仰赖输入元素的随机性。hashtable概述hashtable通过hash function将元素映射到不同的位置，但当不同的元素通过hash...
哈希表（HashTable）C++实现.docx
03-01
在C++中，标准模板库(STL)提供了一个名为`std::unordered_map`的容器，它是一种高效的哈希表实现。 #### 二、`std::unordered_map`简介 `std::unordered_map`是C++标准库中的一种关联容器，用于存储键值对。与传统...
哈希表应用C++_STL_hash
12-14
以上就是关于C++ STL中的哈希表及其应用的基本知识，它在很多场景下提供了高效的数据处理能力，是C++编程中不可或缺的一部分。通过理解和熟练掌握这些概念和用法，能有效提升程序的效率和可读性。
哈希表存储的电话号码查询
10-19
在C++中，可以使用动态内存分配来创建可变大小的数组，同时利用STL中的容器（如`std::vector`）或自定义的数据结构来实现哈希表的存储部分。此外，C++的面向对象特性也使得封装和抽象数据类型成为可能，有助于提高...
数据结构的哈希表使用C++实现
05-09
哈希表，也被称为散列表，是一种非常重要的数据结构，它在...以上就是关于哈希表及其C++实现的一些基本知识，希望能对你学习数据结构有所帮助。在实践中，不断尝试和优化哈希表的实现，可以进一步提升其性能和适用性。
哈希表 华北电力大学
06-20
了解并掌握哈希表及其冲突解决策略对于提升编程效率至关重要。在华北电力大学的课程中，学生会深入学习哈希表的原理、设计和优化，以及如何在实际编程项目中有效地使用它。通过实践，学生不仅能理解哈希表的理论知识...
【STL源码剖析】总结笔记（10）：哈希表（hashtable）探究
斯塔克家的真维斯的工作间
11-30 873
00 写在前面 平衡二叉搜索树中的RB-tree作为一种效率表现和复杂度很平衡的结构，一直被用作STL set和map的底层支持。 【STL源码剖析】总结笔记（8）：红黑树（RB-tree）探究 【STL源码剖析】总结笔记（9)：set/multiset与map/multimap 而还有一种结构，哈希表（以下称hashtable），在数据具有足够的随机性时，也能够保持在插入删除等操作上的“常数平均时间”表现。也是unordered结构的基础。 hashtable更多的是经验设计 01 概述 hasht
STL 简单 hashtable 的实现
chengonghao的博客
05-31 4119
1. 简介          Hash_table可提供对任何有名项（nameditem）的存取、删除和查询操作。由于操作对象是有名项，所以hash_table可被视为是一种字典结构（dictionary）。          Hash_table使用名为hashfaction的散列函数来定义有名项与存储地址之间的映射关系。使用hash faction会带来一个问题：不同的有名项可能被映射到相
STL之哈希表
Spring_24的博客
04-19 927
本文主要介绍哈希表相关内容。
stl之哈希表
IOT_SHUN的博客
03-15 296
hash_map基于hash table（哈希表）。 哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存...
STL之(哈希表）hashtable
jyh的博客
08-12 5487
容器hashtable(哈希表）：另外一种底层机制 其基本原理是：使用一个下标范围比较大的数组来存储元素。把关键字Key通过一个固定的算法函数即所谓的哈希函数（散列函数）转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的list空间里。也可以简单的理解为，按照关键字key为每一个元素“分类”，然后将这个元素存储在相应“类”所对应的地...
STL HashTable实现剖析
u010523811的博客
09-08 130
hashtable，由于要一直满足 load_factor <= max_load_factor ，限制着hash冲突程度，即每个桶的链表节点数不会无限制增加，整个hashtable的节点数达到一定程度就会Rehash，确保hashtable的搜索、删除的平均时间复杂度还是O(1)。综上，同经典的vector+链表的buckets相比，STL中_Hashtable类的buckets的实现为一个元素类型为的_Hash_node_base*数组。2.1 将新节点4指向_M_before_begin的next;
STL中的hashtable
wxwjiayou的博客
03-11 651
一：hashtable概述  1.它的节点是hash table node（并不是listNode）。  2.表格用的是vector，其大小是28个指数中最接近所要求的数。  3.用开链法。  4.其迭代器没有减操作，也没有逆向迭代器。  5.重建表格：当元素个数>hashtable表格的大小时要求重建表格，重建表格是要将每一个元素重新进行hash，然后再delete掉oldhashta
C++ STL --哈希表
cat_fish_rain的博客
07-01 2397
在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到$log_2N$，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对和进行介绍，和学生可查看文档介绍。是存储键值对的关联式容器，其允许通过keys。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值