2021/06/07 散列表之除留余数法以及平方探测法

最新推荐文章于 2024-07-11 10:17:27 发布

原创

最新推荐文章于 2024-07-11 10:17:27 发布 · 1.1k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#c语言

给出一个序列:

47 7 29 11 9 84 54 20 30

如何才能对它们进行排序并且要查找它的位置的时候特别方便?

散列表就是找出每一个数据的关键字并且按照关键字存放在特定的位置;

核心思想就是弄一个映射函数H（key），使得key的位置ret=H（key）

除留余数法是找出某个数字p，让位置ret=key%p;

当然很有可能在存放了几个之后就会有重叠位置的情况发生,也就是冲突。

这里解决冲突的方法是平方探测法：让这个重叠的初始位置ret去加Di；

Di是一段序列:1^2,-1^2,2^2,-2^2.... 其中i是发生冲突的次数

例如说p=11.存放数字7的时候没问题（ret=7%11=7），然而存放29的时候（ret=29%11=7）

发生了冲突,那么第一次冲突就加1,也就是前进一格.8这个位置没有别的数据,不会冲突，所以存放在8;冲突解决

如果8这个位置也存放了其他的数字,那就是第二次冲突,这次要加D2也就是ret=(-1)=6;倒退一格

如果6这个位置也冲突那么就加D3也就是加4,前进四格...

循环下去直到找到空位置为止.

这里关键是找到这里的“某个数字p”。除留余数法中的p指的其实是散列表的最大储存空间。一般是比原序列大的素数。取素数是为了减少冲突。

这里的p用Tablesize表示

它的算法是由Nextprime函数

最低0.47元/天解锁文章

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

兄dei！

关注关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

[查找] 哈希表 | 散列表 - 例子：线性探查法、链地址法

geodoer

09-11

3448

【哈希表 | 散列表】根据关键字的值来计算出关键字在表中的地址 address = H(key) 【哈希函数|散列函数】函数H(key) 举例构造查找查找成功的分析查找失败的分析构造哈希函数哈希函数冲突处理方法开放地址法链地址法查找失败的次数装填因子举例构造【问题举例】 1. 关键字序列为{7, 4, 1, 14, 10...

数据结构与算法之散列表的查找算法

最新发布

AI 算法实战派

05-13

720

散列表作为一种重要的数据结构，在计算机科学领域有着广泛的应用。本文的目的是深入介绍散列表的查找算法，包括其原理、实现和应用。范围涵盖了散列表的基本概念、常见的哈希函数、冲突处理方法，以及如何使用Python实现散列表的查找算法。同时，还会探讨散列表在实际场景中的应用和相关的性能分析。本文将按照以下结构进行组织：首先介绍散列表的背景知识，包括相关术语的定义；接着详细讲解散列表的核心概念，如哈希函数和冲突处理方法；然后阐述散列表查找算法的原理，并使用Python代码进行实现；

参与评论您还未登录，请先登录后发表或查看评论

【除留余数法定义hash函数+平方探测法解决hash冲突】数据结构实验之查找五：平方之哈希表

BlessingXRY的博客

12-17

1648

Think: 1知识点：除留余数法定义hash函数+平方探测法解决hash冲突 2反思 & 思考： hash冲突数据： 4 5 1 6 11 16数据结构实验之查找五：平方之哈希表 Time Limit: 400MS Memory Limit: 65536KBProblem Description 给定的一组无重复数据的正整数，根据给定的哈希函数建立其对应hash表，哈希函数是H(Ke

(4)散列函数设计：除留余数法

wangpengqi的专栏

08-02

1万+

除留余数法介绍 除留余数法此方法为最常用的构造散列函数方法。对于散列表长为m的散列函数公式为： f( key ) = key mod p ( p ≤ m ) mod是取模（求余数）的意思。事实上，这方法不仅可以对关键字直接取模，也可在折叠、平方取中后再取模。一个例子很显然，本方法的关键就在于选择合适的p, p如果选得不好，就可能会容易产生同

散列表哈希（除留余数法）

m0_52103105的博客

07-26

1059

#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define HASHSIZE 12 #define NULLKEY -(1<<31) int m; typedef struct { int *elem; //动态数组 int count; //记录哈希表元素个数 }HashTable; void Init(HashTable *H) { m = HAS

开散列表（除留余数法）

sjy的博客

10-27

758

开散列表

散列表查找（哈希表）-简单概述和算法实现（除留余数法，开发地址法的线性探测）（C语言）

偶然路过的帅小伙z的博客

04-07

1317

目录基本概念构造散列函数的方法处理散列冲突的方法 散列表的查找效率分析 散列表查找算法实现结构定义初始化散列函数插入构造总结

查找——散列表（哈希表）的查找

Blusher1的博客

07-11

1267

这篇文章则介绍散列表（即哈希表）的查找方法。

算法与数据结构 --- 查找 --- 散列表的查找

qq_51947882的博客

09-27

1542

1.开放地址法其实就是在出现冲突的时候，那么我们就在表中找一个新的存储位置来存储元素，如果这个存储位置对应的元素还不为空的话，那就继续存到新的存储位置，直到找到元素为空的存储位置为止（如果找编所有的存储位置都不行的话，那就返回表已满）查找的时候也同理，如果查找的值的关键字和计算出的存储位置的元素的关键字不同的话，我们就用整数取余法去看其它的存储位置元素，如果还是不相等的话那就继续获取新存储位置来查找，直到找到或者是存储位置超出散列表范围为止。

python散列表链地址法解决冲突 除留余数法散列插入删除查找操作（详细注释）

Wang_Runlin的博客

03-05

2727

散列是数据结构中较为重要的内容。两种基本方法之一的链地址法虽稍繁琐，但思路较简单，过程清晰。 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找速度。这个映射函数叫做散列函数，记录的数组叫做散列表。散列函数：除留余数法（取关键字被某个不大于散列表表长m的数p除后所得的余数为散...

c实现的哈希表（除留余数法、链地址法）（包含设计文档）

06-09

. c实现的哈希表。哈希函数采用除留余数法，处理哈希冲突采用链地址法。包含设计文档！在dev c++上验证过。. vs2010 中有代码.有修改过一些BUG.

1、哈希表类的哈希函数采用除留余数法哈希函数；

12-15

哈希查找： 1、哈希表类的哈希函数采用除留余数法哈希函数； 2、解决哈希冲突的函数采用开放定址法中的线性探察法。 3、建立一个由10个数据元素组成的集合； 4、测试哈希表长度m=13和m=11两种情况下的哈希表，并查找其中的几个元素。

散列函数的构造方法：除留余数-链地址法

weixin_54452498的博客

11-11

1518

相同散列地址的记录链成一个单链表，m个散列地址就设m个单链表的表头指针存储起来，形成一个动态的结构例子：关键字{19,14,23,1,68,20,84,27,55,11,10,79} Hash(key)=key mod n（也就是对key取余）（n通常取散列表长度）设散列函数为 Hash(key)=key%13 则可得结果：用c实现： //c语言代码 #include <stdio.h> #include <stdlib.h> #define m 13//...

除留余数法学习

热门推荐

qq_36498850的博客

02-07

1万+

除留余数法python_Python数据结构与算法分析 day19

weixin_42517503的博客

01-24

615

Python数据结构与算法分析day191散列前边我们利用数据集中关于数据项之间排列关系的知识，来将查找算法进行了提升。如果数据项之间是按照大小排好序的话，就可以利用二分查找来降低算法复杂度。现在我们进一步来构造一个新的数据结构能使查找算法的复杂度降为O(1)，这种概念称为散列。要想使查找的次数降低到常数级别，就要对数据项所处的位置有更多的先验知识。如果我们事先能知道要找的数据项应该出...

数据结构和算法——散列函数的构造方法（直接定址法、除留余数法、数字分析法、折叠法、平方取中法、ASCII码加和法、前三字符移位法）

li13437542099的博客

08-08

2037

数据结构和算法——散列函数的构造方法（直接定址法、除留余数法、数字分析法、折叠法、平方取中法、ASCII码加和法、前三字符、移位法）我们发现32是2的5次方，于是可以通过移位，也就是将一个数往左二进制移位五次，就相当于*32.，取后三位391，所以h（56793542） =种，但经过统计得到，实际中的组合约3000种，，即空间利用率大约30%，浪费了70%的空间。，理论上来说，前三字符所有可能性的组合为。

数据结构-哈希表-使用最简单的除留余数法实现基本操作

JunsIr的技术栈

12-23

4300

数据结构-哈希表-基本操作代码说明：本篇仅提供可运行代码，具体讲解笔记请进哈希本篇代码设计哈希表查找、插入操作代码（经VS2015、devC++编译运行通过） #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define...

哈希函数直接定址法 除留余数法

weixin_30438813的博客

06-29

2692

直接定址法直接定址法是以数据元素关键字k本身或它的线性函数作为它的哈希地址，即：H（k）=k或H（k）=a×k+b；(其中a,b为常数) 例1，有一个人口统计表，记录了从1岁到100岁的人口数目，其中年龄作为关键字，哈希函数取关键字本身，如图(1)：地址 A1 A2 …… A99 A100 ...

哈希表算法原理

u012371712的博客

04-22

4581

原文地址：https://blog.mimvp.com/article/5724.html今天看到这篇文章重新对哈希表和字典有了新的认识，希望你看到这篇文章。仔细看一下，再到微软官网仔细看一下MSDN，这块内容还是有很高的研究价值的。基本概念哈希表（Hash Table）是一种根据关键字直接访问内存存储位置的数据结构。通过哈希表，数据元素的存放位置和数据元素的关键字之间建立起某种对应关系，建立这种...

用JAVA语言设计下列算法：1．问题：若某单位职工有 n 名，试以职工的姓名为关键码，设计散列表，请完成相应的建表和查询功能。 2．要求 (1）假设每名职工的姓名以汉语拼音形式表示。待填入散列表的人名共有 n 个。请构造合适的散列函数，选择恰当的处理冲突的方法来构造散列表。 (2）输入职工的姓名，实现在散列表中检索职工的信息，显示检索的过程。提示：一般情况下，人的姓名包含2~4个汉字，因此拼音的长度不超过24个字符。一个字的拼音一般由拼音字母组成，字母是有限的，因此可以考虑对拼音字母进行编号，那么一个姓名的编号就是一串数字，以此数字为关键码，根据职工人数 n 确定散列表的长度 m ，采用除留余数法来计算散列地址。处理冲突的方法：好的散列函数使得散列地址在散列表中分布较均匀，发生冲突的机会较小，但冲突是不可避免的，发生冲突时，采用开放定址法处理冲突，可采用二次探测法形成探测序列。 3．测试数据请选取随机6个人的姓名进行测试。

05-07

<think>好的，我现在需要帮用户设计一个基于Java的散列表算法，使用职工姓名作为关键码，处理冲突的方法是开放定址法。首先，我得理清楚用户的需求。用户提到用除留余数法计算地址，那散列函数的设计应该是将姓名转换为一个数值，然后取模得到索引。不过，如何将拼音形式的姓名转换为数值呢？接下来，处理冲突的方法使用开放定址法，具体是哪种探测方式呢？线性探测、平方探测还是双重散列？用户没有明确说明，可能需要选择最常见的方式，比如线性探测。不过需要确认用户是否有偏好，但这里可能默认线性探测。然后，建表和查询功能的实现。首先，散列表的结构需要确定，比如数组的大小，这里可能需要一个合适的大小，最好是素数，这样可以减少冲突。用户可能没有指定表的大小，需要动态调整吗？或者固定大小？可能先假设用户需要一个固定大小的表，比如使用一个默认的容量，比如10007，这样是一个较大的素数，减少冲突概率。接下来，散列函数的设计。职工姓名是拼音形式，比如“zhangsan”。需要将每个字符转换成ASCII码，然后相加或者进行某种组合。可能需要考虑如何将字符串转化为一个整数。常见的方法是将每个字符的ASCII值乘以一个权值，比如31的幂次，然后累加。例如，计算字符串的哈希值时，使用多项式累积：h = s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]。但这里用户要求使用除留余数法，所以最终的哈希值是这个累积值对表大小取模。但是，Java本身的String类的hashCode()方法就是使用类似的算法，所以可能直接使用字符串的hashCode()，然后取模。不过需要确保模的是表的大小，并且处理可能的负数。比如，hashCode()可能返回负数，所以需要取绝对值再模表大小。然后处理冲突。当发生冲突时，使用开放定址法中的线性探测，即从冲突的位置开始，依次查找下一个可用的位置，比如index = (hash + i) % capacity，其中i从1开始递增，直到找到空的位置或遍历整个表。接下来，构建散列表的结构。可能需要一个Entry类来保存键值对，这里键是姓名，值可能是职工的其他信息，但用户可能只需要存储姓名作为关键码，所以或许可以简化结构。或者，用户可能需要存储职工对象，但问题描述中没有具体说明，可能假设键是姓名，值可能关联其他数据，但示例中可以简化为存储姓名作为键。实现插入方法时，计算哈希值，然后检查该位置是否被占用。如果被占用，就线性探测下一个位置，直到找到空的位置或已存在的同名键（可能需要处理重复的情况）。查询方法类似，计算哈希值后，检查该位置，如果存在键匹配则返回，否则继续探测，直到找到空的位置或者遍历整个表。需要注意的是，当表快满时，线性探测的效率会下降，可能需要考虑动态扩容，但用户可能只需要基础实现，所以暂时不考虑扩容，假设表足够大。现在，编写Java代码。首先定义HashTable类，内部使用一个数组来存储Entry对象，Entry包含key和可能的value。这里可能简化，假设每个位置存储的是职工的姓名作为键，或者存储一个Employee对象。但根据用户需求，可能键是姓名，所以Entry类可以包含key（String）和value（可能其他信息，但用户可能只需要处理冲突，所以可能不需要存储额外数据，或者示例中可以存储一个占位符）。不过用户的问题可能更关注结构而非存储数据，所以可能键就是职工姓名，值可以简单设为true或类似，或者存储职工对象。但为了示例，可能直接存储姓名作为键，并假设值不重要，或者使用一个简单的结构。例如： class HashTable { private int capacity; private String[] table; // 或者使用Entry类，包含key和value // 但用户可能只需要处理冲突，所以可能用String数组即可，空位置为null，已占用的位置为姓名 public HashTable(int capacity) { this.capacity = capacity; table = new String[capacity]; } // 散列函数 private int hashFunction(String name) { int hash = name.hashCode(); return (Math.abs(hash) % capacity); } // 插入方法，处理冲突 public void insert(String name) { int index = hashFunction(name); int i = 0; while (i < capacity) { int currentIndex = (index + i) % capacity; if (table[currentIndex] == null || table[currentIndex].equals(name)) { // 假设允许重复插入或更新？ table[currentIndex] = name; return; } i++; } throw new RuntimeException("HashTable is full"); } // 查询方法 public boolean search(String name) { int index = hashFunction(name); int i = 0; while (i < capacity) { int currentIndex = (index + i) % capacity; if (table[currentIndex] == null) { return false; } if (table[currentIndex].equals(name)) { return true; } i++; } return false; } } 不过这样可能存在一些问题。例如，当表中存在已删除的节点时，线性探测需要处理“墓碑”标记，否则查询可能提前终止。但用户的问题中没有提到删除功能，所以可能暂时忽略，假设不需要处理删除操作。另外，散列函数是否正确处理了负数的hashCode？Math.abs可能有问题，因为当hashCode是Integer.MIN_VALUE时，Math.abs会溢出，导致负数。所以更安全的做法是取模后处理负数： return (hash % capacity + capacity) % capacity; 这样可以确保结果是非负的。然后，测试代码，例如插入几个名字，然后查询是否存在。不过用户可能需要更详细的实现，包括如何处理冲突，使用开放定址法，所以代码中的insert方法在冲突时会线性探测下一个位置。此外，用户可能需要更完整的示例，比如主函数中的测试案例。现在，总结步骤： 1. 设计散列函数：使用字符串的hashCode()，然后取模表的大小，处理负数。 2. 处理冲突：线性探测，即如果位置被占用，依次检查下一个位置。 3. 实现插入和查询方法，遵循开放定址法的线性探测。可能还需要考虑表的大小是否为素数，以减少冲突。在构造函数中，可以检查传入的容量是否为素数，或者自动调整为最近的素数。但用户可能希望简单，所以示例中使用默认的素数容量，比如10007。最后，生成相关问题，例如关于散列函数的选择、处理冲突的其他方法、性能分析等。</think>### 基于Java的散列表实现方案 #### 一、设计思路 1. **散列函数设计**：使用字符串多项式转换结合除留余数法 将职工姓名字符串转换为整数：$hash = (\sum_{i=0}^{n-1} s[i] \times 31^{n-1-i}) \bmod tableSize$ 其中$s[i]$为字符ASCII码，$n$为字符串长度[^1] 2. **冲突处理**：采用线性探测开放定址法冲突时按公式计算新位置：$newIndex = (hash + probe) \bmod tableSize$，$probe$从1开始线性递增 #### 二、完整实现代码 ```java public class EmployeeHashTable { private static final int DEFAULT_CAPACITY = 10007; // 建议使用素数 private final String[] table; private final int capacity; public EmployeeHashTable() { this(DEFAULT_CAPACITY); } public EmployeeHashTable(int capacity) { this.capacity = capacity; this.table = new String[capacity]; } // 散列函数实现 private int hashFunction(String name) { int hash = 0; for (int i = 0; i < name.length(); i++) { hash = (31 * hash + name.charAt(i)) % capacity; } return (hash + capacity) % capacity; // 确保非负 } // 插入方法 public void insert(String name) { int index = hashFunction(name); int probe = 0; while (probe < capacity) { int currentIndex = (index + probe) % capacity; if (table[currentIndex] == null) { table[currentIndex] = name; return; } probe++; } throw new RuntimeException("Hash table overflow"); } // 查询方法 public boolean contains(String name) { int index = hashFunction(name); int probe = 0; while (probe < capacity) { int currentIndex = (index + probe) % capacity; if (table[currentIndex] == null) { return false; } if (table[currentIndex].equals(name)) { return true; } probe++; } return false; } } ``` #### 三、关键实现细节 1. **素数容量选择**：使用10007作为默认表大小，该素数的选择能有效减少散列冲突。若需动态扩容，建议每次扩容为大于当前容量两倍的最小素数 2. **线性探测优化**： ```java // 改进的探测序列可降低聚集现象 int currentIndex = (index + probe*(probe+1)/2) % capacity; // 平方探测 ``` 3. **性能指标**：装填因子$\alpha$应控制在0.7以下，当$\alpha = n/m > 0.7$时，查找成功平均比较次数约$\frac{1}{2}(1+\frac{1}{1-\alpha})$[^2] #### 四、测试用例 ```java public static void main(String[] args) { EmployeeHashTable ht = new EmployeeHashTable(); ht.insert("zhangsan"); ht.insert("lisi"); ht.insert("wangwu"); System.out.println(ht.contains("lisi")); // true System.out.println(ht.contains("zhaoliu")); // false } ```