14 哈希表查找
哈希表查找方法原理
哈希表查找方法原理哈希表查找方法什么是哈希表•哈希表是一种常见的数据结构，也被称为散列表。
•它可以提供快速的插入、删除和查找操作，时间复杂度在平均情况下为O(1)。
•哈希表由数组组成，每个数组元素称为桶(bucket)。
•存储数据时，通过哈希函数将数据映射到对应的桶中。
哈希函数的作用•哈希函数是哈希表的核心部分，它将数据转换为哈希值。
•哈希函数应该具备以下特点：–易于计算：计算哈希值的时间复杂度应尽量低。
–均匀分布：哈希函数应能将数据均匀地映射到不同的桶中，以避免桶的过度填充或者空闲。
–独特性：不同的输入应该得到不同的哈希值，以尽量减少冲突。
哈希冲突及解决方法•哈希冲突指两个或多个数据被哈希函数映射到同一个桶的情况。
•常见的解决哈希冲突的方法有以下几种：–链地址法(Chaining)：将相同哈希值的数据存储在同一个桶中，通过链表等数据结构来解决冲突。
–开放地址法(Open Addressing)：当发生冲突时，通过特定的规则找到下一个可用的桶来存储冲突的数据，如线性探测、二次探测等。
–再哈希法(Rehashing)：当发生冲突时，使用另一个哈希函数重新计算哈希值，并将数据存储到新的桶中。
哈希表的查找方法•哈希表的查找方法分为两步：1.根据哈希函数计算数据的哈希值，并得到对应的桶。
2.在桶中查找目标数据，如果找到则返回，否则表示数据不存在。
哈希表的查找性能•在理想情况下，哈希表的查找时间复杂度为O(1)。
•然而，由于哈希冲突的存在，查找时间可能会稍微增加。
•如果哈希函数设计得不好，导致冲突较多，可能会使查找时间复杂度接近O(n)。
•因此，选择合适的哈希函数和解决冲突的方法对于提高哈希表的查找性能非常重要。
总结•哈希表是一种高效的数据结构，适用于快速插入、删除和查找操作的场景。
•哈希函数的设计和解决冲突的方法直接影响哈希表的性能。
•在实际应用中，需要根据数据特点选择合适的哈希函数和解决冲突的方法，以提高哈希表的查找性能。
哈希表查找成功和不成功的算法
哈希表查找不成功怎么计算？解答：先建好表，然后可以算出每个位置不成功时的比较次数之和，再除以表空间个数！例如：散列函数为hash(x)=x MOD 13，用线性探测，建立了哈希表之后，如何求查找不成功时的平均查找长度！？地址：0 1 2 3 4 5 6 7 8 9 10 11 12数据： 39 1228154244 625－－ 36－ 38成功次数： 1 3 1 2 2 1 191 1不成功次数：98 7 65 4 3 2 1 1 2 110查找成功时的平均查找长度:ASL=(1+3+1+2+2+1+1+9+1+1)/10 =2.2查找不成功时的平均查找长度:ASL=(9+8+7+6+5+4+3+2+1+1+2+1+10)/13=4.54说明：第n个位置不成功时的比较次数为，第n个位置到第1个没有数据位置的距离。
至少要查询多少次才能确认没有这个值。
（1）查询hash(x)=0,至少要查询9次遇到表值为空的时候，才能确认查询失败。
（2）查询hash(x)=1,至少要查询8次遇到表值为空的时候，才能确认查询失败。
（3）查询hash(x)=2,至少要查询7次遇到表值为空的时候，才能确认查询失败。
（4）查询hash(x)=3,至少要查询6次遇到表值为空的时候，才能确认查询失败。
（5）查询hash(x)=4,至少要查询5次遇到表值为空的时候，才能确认查询失败。
（6）查询hash(x)=5,至少要查询4次遇到表值为空的时候，才能确认查询失败。
（7）查询hash(x)=6,至少要查询3次遇到表值为空的时候，才能确认查询失败。
（8）查询hash(x)=7,至少要查询2次遇到表值为空的时候，才能确认查询失败。
（9）查询hash(x)=8,至少要查询1次遇到表值为空的时候，才能确认查询失败。
（10）查询hash(x)=9,至少要查询1次遇到表值为空的时候，才能确认查询失败。
（11）查询hash(x)=10,至少要查询2次遇到表值为空的时候，才能确认查询失败。
数据结构习题及答案 (1)
第八章查找一、判断题1.用二分查找法对一个顺序表进行查找，这个顺序表可以是按各键值排好序的，也可以是没有按键值排好序的。
（）2.哈希表的查找不用进行关键字的比较。
（）3.哈希表的定义函数H（key）=key%p(p<=m)这种方法是直接定址法。
（）4.装填因子α的值越大，就越不容易发生冲突。
( )5.选择hash函数的标准为：随机性好、均匀性好和尽量避免冲突。
( )参考答案：1、×2、×3、×4、×5、√二、填空题1.顺序查找法的平均查找长度为__________，二分查找法的平均查找长度为________，分块查找法(以顺序查找确定块)的平均查找长度为__________，分块查找法(以二分查找确定块〉的平均查找长度为_________，哈希表查找法采用链接法处理冲突时的平均查找长度为_________。
(n+1)/2；((n+1)*log2(n+1))/n-1；(s2+2s+n)/2s；log2(n/s+1)+s/2；1+α2.在各种查找方法中,平均查找长度与结点个数n无关的查法方法是_________哈希表查找3.二分查找的存储结构仅限于_________,且是__________。
顺序；有序的4.在分块查找方法中,首先查找__________,然后再查找相应的___________。
索引；块5.长度为255的表,采用分块查找法,每块的最佳长度是____________。
156.在散列函数H(key)=key%p中,p应取_______________。
小于表长的最大素数7.假设在有序线性表A[1..20]上进行二分查找,则比较一次查找成功的结点数为_________,则比较二次查找成功的结点数为__________,则比较三次查找成功的结点数为_________,则比较四次查找成功的结点数为________,则比较五次查找成功的结点数为_________,平均查找长度为_________。
哈希表的平均查找长度
哈希表的平均查找长度
哈希表是计算机科学中最常用的存储结构之一，它也被称为散列表。
它的功能是将数据的键(key)映射到另一个存储空间，即值（value）。
由于它的高效查找性能，哈希表正在被广泛使用，例如使用哈希表实现集合、映射和缓存。
一. 什么是哈希表?
1. 定义：哈希表是一种存储结构，它通过键（key）映射到其对应的值（value）。
2. 特点：哈希表具有较高的查找效率，可以在常数时间内获取键对应的值。
二. 如何实现哈希表?
1. 数组：哈希表可以使用一个数组来存储键值对，使用数组索引作为键（key），值（value）是存储在数组中的相应元素。
2. 链表：哈希表也可以使用链表来实现，将键（key）哈希成索引，索引对应的是一个链表。
三. 哈希表的平均查找长度
1. 一致性Hash：实现一致性哈希函数，把数据映射到一个虚拟环上，以哈希函数实现数据的索引，中间没有冲突，可以实现O（1）平均时间查找。
2. 拉链法：使用一个数组，其中每个数组元素是一个链表，当存有多条Key值相同的元素时可以放在同一个链表中，使用拉链法实现哈希表，查找的时间复杂度是O(n)。
3. 开放寻址法：开放寻址法通过查找空位和再散列的方式解决Key值的冲突，使用平方探测和双散列来发现空位，查找的时间复杂度是
O(1+α)，其中α是探测次数。
总结：哈希表是一种非常有效的存储结构，由于它的高效查找性能，哈希表可以实现O（1）的平均查找长度，它有三种实现方式，分别是数组，链表和开放寻址法，它们的查找时间复杂度也有所不同，由于查找的时间复杂度越低效率越高，所以选择一种实现方式时要根据自身的需求做出最佳选择。
哈希表find函数
哈希表find函数哈希表find函数是哈希表中常用的一个函数，用来查找指定关键字所对应的数据。
一、哈希表find函数的定义哈希表find函数的定义如下：```template<typename Key, typename Value>typename HashTable<Key, Value>::Iterator HashTable<Key, Value>::find(const Key& key) const```其中，HashTable<Key, Value>是一个哈希表模板类，Iterator是一个迭代器类，Key表示关键字类型，Value表示值类型。
二、哈希表find函数的实现哈希表find函数的实现分为以下几步：1. 计算关键字的哈希值哈希表的基本思想是将关键字映射到一个固定的位置上，该位置称为哈希桶，在哈希表中存储数据。
因此，首先需要计算关键字的哈希值，将其映射到对应的哈希桶上。
2. 查找对应的哈希桶计算出哈希值后，需要找到对应的哈希桶。
哈希表通常采用链表或者红黑树等数据结构来解决哈希冲突的问题，因此需要遍历哈希桶，查找指定关键字是否在其中。
3. 查找指定关键字在找到对应的哈希桶后，需要遍历哈希桶查找指定关键字。
通常采用迭代器来遍历链表或者红黑树，查找指定关键字是否在其中。
三、哈希表find函数的使用使用哈希表find函数非常简单，只需要传入要查找的关键字即可。
使用方法如下：```HashTable<int, std::string> hashTable;hashTable.insert(std::make_pair(1, "hello"));hashTable.insert(std::make_pair(2, "world"));auto iter = hashTable.find(1);if (iter != hashTable.end()){std::cout << iter->second << std::endl; // 输出hello}else{std::cout << "not found" << std::endl;}```以上代码创建了一个哈希表，并向其中插入两个键值对。
哈希表——线性探測法、链地址法、查找成功、查找不成功的平均长度
哈希表——线性探測法、链地址法、查找成功、查找不成功的平均长度⼀、哈希表1、概念哈希表(Hash Table)也叫散列表，是依据关键码值（Key Value）⽽直接进⾏訪问的数据结构。
它通过把关键码值映射到哈希表中的⼀个位置来訪问记录，以加快查找的速度。
这个映射函数就做散列函数。
存放记录的数组叫做散列表。
2、散列存储的基本思路以数据中每⼀个元素的keywordK为⾃变量。
通过散列函数H（k）计算出函数值，以该函数值作为⼀块连续存储空间的的单元地址，将该元素存储到函数值相应的单元中。
3、哈希表查找的时间复杂度哈希表存储的是键值对，其查找的时间复杂度与元素数量多少⽆关。
哈希表在查找元素时是通过计算哈希码值来定位元素的位置从⽽直接訪问元素的，因此，哈希表查找的时间复杂度为O（1）。
⼆、经常使⽤的哈希函数1. 直接寻址法取keyword或者keyword的某个线性函数值作为哈希地址,即H(Key)=Key或者H(Key)=a*Key+b(a,b为整数),这样的散列函数也叫做⾃⾝函数.假设H(Key)的哈希地址上已经有值了,那么就往下⼀个位置找,知道找到H(Key)的位置没有值了就把元素放进去.2. 数字分析法分析⼀组数据,⽐⽅⼀组员⼯的出⽣年⽉,这时我们发现出⽣年⽉的前⼏位数字⼀般都同样,因此,出现冲突的概率就会⾮常⼤,可是我们发现年⽉⽇的后⼏位表⽰⽉份和详细⽇期的数字区别⾮常⼤,假设利⽤后⾯的⼏位数字来构造散列地址,则冲突的⼏率则会明显减少.因此数字分析法就是找出数字的规律,尽可能利⽤这些数据来构造冲突⼏率较低的散列地址.3. 平⽅取中法取keyword平⽅后的中间⼏位作为散列地址.⼀个数的平⽅值的中间⼏位和数的每⼀位都有关。
因此，有平⽅取中法得到的哈希地址同keyword的每⼀位都有关。
是的哈希地址具有较好的分散性。
该⽅法适⽤于keyword中的每⼀位取值都不够分散或者较分散的位数⼩于哈希地址所须要的位数的情况。
哈希表的定义查找及分析bklt
一、直接地址法
：
取关键字或关键字的某个线性函值为哈希地址
即： H(key) = key 或： H(key) = a* key + b
其中，a， b为常数。
二、数字分析法
假设关键字集合中的每个关键字都是由 s 位 数字组成 (u1, u2, …, us)，分析关键字集中的全 体， 并从中提取分布均匀的若干位或它们的组 合作为地址。
查找不成功时的ASL
ASLunsucc=( )/11
= /11
10
11
3
8
线性探测再散列的优点：
只要哈希表未满，总能找到一个空地址。
缺点：会产生二次聚集。
01…
70 19 33 18
5678 9
… 12
9
二、 链地址法
在哈希表的每一个单元中存放一个指针，将所 有的同义词连成一个链表。 假设哈希地址在区间[0 .. m-1]上，则哈希表为
一个指针数组。
typedef struct node{ //定义链表中结点 KeyType key； 其它成员 ； struct node *next；
} Node，*Nodeptr； typedef Nodeptr chainhash[m]；// 定义指针数组10
例1: 关键字集合 { 19, 01, 23, 14, 55, 68, 11, 82, 36 }
若采用线性探测再散列处理冲突
0 1 2 3 4 5 6 7 8 9 10
55 01 23 14 68 11 82 36 19
11 21 3 62 5 1
若采用二次探测再散列处理冲突
0 1 2 3 4 5 6 7 8 9 10
哈希查找的名词解释
哈希查找的名词解释
哈希查找（HashSearch）是一种快速检索技术，通过计算一个项目的哈希值，来快速检索该项目是否存在于数据表中。
它的原理是：数据集合中的每一个元素首先通过哈希函数映射成一个数字，然后根据这个数字对查询表进行定位，再根据查找表中的信息检索出查找的数据。
哈希查找可用于查看某个数据是否存在于某集合之中，也可以用于查看某个数据的各种相关信息。
哈希函数：
哈希函数是一种将原始数据映射成散列值的函数，它常用于实现哈希操作，即从原始数据中找到一个映射而来的数据。
根据哈希函数，相同的原始数据将会映射到相同的散列值上，由此来节省查找时间，提高查找效率。
桶：
桶（Bucket）是哈希查找的一种技术，它是把所有映射到同一散列值上的元素放在同一个桶中，以加快查找速度。
哈希查找时，先根据哈希函数计算出元素的散列值，然后根据这个散列值在桶中查找，直到找到查找元素为止。
哈希表：
哈希表（Hash Table）是一种存储数据的数据结构，它由一个固定大小的数组组成，其中每个元素都以键值对保存数据，其中键是一个数字或字符串，而值是任意类型的数据。
哈希表很容易根据键快速查找到对应的值，因此，使用哈希表可以实现快速查找操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
70
15 ^
18 ^ 30 20 ^
8
63
19 ^
下节内容
排序
h0=4 h1=(4+1)%11=5；
h3 =(8+3)%11=0； h0 h1 h2 h3 h4 h5
h(19)=19%11=8，冲突；
=8 =(8+1)%11=9，冲突; =(8+2)%11=10，冲突; =(8+3)%11=0，冲突; =(8+4)%11=1，冲突; =(8+5)%11=2。
h(8)=8%11=8，冲突；
关键字 机内码 010203 ABC 020304 BCD 030405 CDE 040506 DEF ... ... 机内码的平方数 哈希地址 0104101209 101 0412252416 252 0924464025 1640739036 ... 464 739 ...
折叠移位法
若关键字的位数很多，且每一位上数字分布大
致均匀，则可采用移位叠加或间界叠加，即将
关键字分成若干部分，然后以它们的叠加和(舍 去进位)作为哈希地址。 移位叠加：将各段的最低位对齐相加； 间界叠加：两个相邻的段沿边界来回折叠对 齐相加。
【例5】已知关键字351246783，地址空间的大小 为1000，编号为0-999。用折叠移位法计算散列地 址的过程如下： 根据表长1000，将关键字分成3段，每段3位数字。 移位叠加的散列地址：351 246 +783 (1)380 （舍去进位） 间界叠加的散列地址：351
【例2】统计某地区从1949年到1995年每年出生的 人数，列在一张表中。年份为关键字，因共有 47 年，所以表中位臵范围是1～47。 用直接定址法设臵散列函数 h(k)=k-1948 ，其中 k 为年份数。这样的散列表示意如下：
1 年份 人数 2 ．．． ．．． 47
1949 ．．．
1950 ．．．
1995 ．．．
查找举例：若要查1970年的出生人数，则根据散 列函数（1970-1948=22）计算散列地址，在表的 第22个位臵即可找到。
除留余数法
以关键字被某个整数m除后所得余数作为散列
地址。 h(k)=k ％ m （m<=表长） 使得数据集合中的每一个关键字通过该函数转 化后映射到哈希表的任意地址上的概率相等。 理论研究表明，在m取值小于或等于表长的为 素数时，冲突可能性相对较少。 常用方法，通常结合其它方法一起使用。
乔布斯：Windows又烂又慢，还经常死机啊！ 盖茨：对啊。 乔布斯：那为什么不改进一下？ 盖茨：改进了男生还怎么进女生宿舍修电脑？
1
上节回顾
二叉排序树的插入
三种可能 二叉排序树的查找 与根比较，三种结果 二叉排序树的删除 删除叶子结点 删除单支结点 删除双支结点
散列
什么是散列
同顺序存储结构和链式存储结构一样，散列也
直接定址法
除留余数法
数字分析法
平方取中法
折叠移位法
直接定址法
取关键字本身或关键字的某个线性函数值作为
散列地址。 h(key)=key 或 h(key)=a×key+b （a 和 b 均为常数） 直接定址所得地址集的大小和关键字集的大小 相同，关键字和地址一一对应，决不会产生冲 突。但实际应用能采用直接定址的情况极少， 会造成存储空间的浪费， 适用于关键字基本连 续的情况。 例如，给定关键字序列{1,45,99}若采用h(k)=k 作为散列函数，则地址集为(1~99)，但只存放3 个关键字，空间浪费严重。
923 17 6 02 923 26 8 75 927 39 6 28 923 43 6 34 927 06 8 16 927 74 6 38 923 81 2 62 2 75 28 34 16 38 62
平方取中法
如果关键字的所有各位分布都不均匀或较分散
的位数小于散列地址所需位数，则可取关键字
【练习】已知散列表地址区间为 0 ～ 10 ，给 定关键字序列（ 20 ， 30 ， 70 ， 15 ， 8 ， 12， 18，63，19）。哈希函数为h(k)=k％ll，分 别采用线性探查法和链地址法处理冲突，构 造散列表。要求写出各自的计算过程并画出 对应的散列表。
线性探测法
h(20)=20%11=9； h(63)=63%11=8，冲突； h0 =8 h(30)=30%11=8； h1 =(8+1)%11=9，冲突; h(70)=70%11=4； h2 =(8+2)%11=10，冲突; h(15)=15%11=4，冲突；
0 70 1 2 3 4 5 30 18 12 6 20
数字分析法
如果可能出现的关键字的数位相同，且取值事
先知道，则可对关键字进行分析，取其中“分布
均匀”的若干位或它们的组合作为散列表的地址。
【例3】对如下一组关键字通过分析可知：每个关 键字从左到右的第l，2，3位和第6位取值较集中， 不宜作哈希地址。剩余的第4，5，7和8位取值较 分散，可根据实际需要取其中的若干位作为散列 地址。 关键字 散列地址
【例1】已知连续的地址区间为0～6，给定关键字 k 的序列 {20 ， 30 ， 70 ， 12 ， 18} 。若将 k％7 的值 作为k的存储地址，则可以构造出以下存储结构。 地址：20%7=6;30%7=2;70%7=0;12%7=5;18%7=4
0 70 1 2 3 4 5 30 18 12 6 20
若 添 加 新 的 关 键 字 “ 14” ， 则 其 散 列 函 数 值 （14%7=0）将与关键字“70”的存储地址相同，产 生冲突。此时14和70称为同义词。
开放定址法
使用某种探查技术，生时，沿此序列逐个单元查找空闲 单元地址。
hi=( h(k)+ di )%m
上例中k％7为散列(哈希)函数 ，构造出的存储结 构称为散列表。若添加新的关键字“14”，则其散 列函数值（14%7=0）将与关键字“70”的存储地址 相同，我们称这种关键字不同但是散列函数值相 同的现象为 冲突。在构造散列表的时候我们须同 时设计某种散列函数和某种处理冲突的方法。
散列函数的构造方法
15
59 34 22 20 35
链地址法
将所有关键字互为“同义词”的元素链接在一个线性链表 中。此时的散列表以“指针数组”的形式出现， “同义词” 链表按哈希地址在“指针数组”中存储链表的头指针。
{15,59,22,34,20,35} h(k)=k％l3
h(15)=15%13=2； h(59)=59%13=7； h(22)=22%13=9； h(34)=34%13=8； h(20)=20%13=7； h(35)=35%13=9；
h0 =8 h1 =(8+1)%11=9，冲突； h2 =(8+2)%11=10；
h(12)=12%11=l； h(18)=18%11=7； 0 1 2 3 4 5 6 7 8 9 10 63 12 19 70 15 18 30 20 8 散列表：
链地址法
h(20)=20%11=9； 散列表： 0 ^ 1 ^ h(30)=30%11=8； 2 ^ h(70)=70%11=4； 3 ^ h(15)=15%11=4； 4 ^ 5 ^ h(8)=8%11=8； 6 ^ h(12)=12%11=l； 7 ^ h(18)=18%11=7； 8 ^ h(63)=63%11=8； 9 ^ 10 ^ h(19)=19%11=8；
的平方值的中间若干位作为散列表的地址。 由于一个数的平方值的中间几位数受该数所有 位影响，将使随机分布的关键字得到的散列函 数值也随机 。 取关键字平方后的中间几位作为散列函数地址 （若超出表长范围时，可再取模）。
【 例 4】 设 有 一 组 关 键 字 ABC，BCD,CDE， DEF，……其对应的机内码如下表所示。假定地址 空间的大小为1000，编号为0-999。现按平方取中 法构造哈希函数，则可取关键字机内码平方后的 中间三位作为存储位臵。计算过程如下：
【例1】已知连续的地址区间为0～6，给定关键字 k 的序列 {20 ， 30 ， 70 ， 12 ， 18} 。若将 k％7 的值 作为k的存储地址，则可以构造出以下存储结构。 地址：20%7=6;30%7=2;70%7=0;12%7=5;18%7=4
0 70 1 2 3 4 5 30 18 12 6 20
是存储数据的一种方法，是将一组关键字映射 到一个有限的、地址连续的地址（区间）上。 散列存储的基本思路：以数据中每个元素的关 键字k为自变量，通过某种函数 H(k) 计算出函 数值，以该函数值作为一块存储空间的单元地 址，将该元素存储到函数值对应的单元中。 H(k) 称为散列函数或哈希(hash)函数。 把如此构造的线性表存储结构称为散列表或哈 希表。
hi指冲突后尝试的下一地址（0 ≤ i ≤ m-1）
线性探查法 di= 1,2,3,…,m-1 平方探查法 di= i2
（0 ≤ i ≤ m-1)
双散列函数探查法
di= di+k2(k) （0 ≤ i ≤ m-1, d0=h(k))
【例 6】已知散列表长 13 ，地址区间 0 ～ 12 ，给定关键字 序列{15,59,22,34,20,35}，散列函数h(k)=k％l3，采用 线性探查法处理冲突，试构造出散列表。 h(15)=15%13=2，存至A[2]；h(59)=59%13=7，存至A[7]。 h(22)=22%13=9，存至A[9]；h(34)=34%13=8，存至A[8]。 h(20)=20%13=7，冲突； h0 =7 h1 =(h0+1)%13=8，仍冲突； h2 =(h0+2)%13=9，仍冲突； h3 =(h0+3)%13=10，存至A[10]； h(35)=35%13=9，冲突；（同义词引起的冲突） h0 =9；h1=(h0+1)%13=10，仍（非同义词）冲突； h2 =(h0+2)%13=11，存至A[11]； 0 1 2 3 4 5 6 7 8 9 10 11 12