已知哈希表长度为 8,哈希函数为 H(k)=kmod7,采用线性探测法处理冲突。 将下列关键字依次插入到哈希表中, 34, 36, 20, 16, 22 请写出存入数据后的哈希表。 若各关键字的检索概率相等,则平均查找长度为 (保留1位小数,末位四舍五入)。
时间: 2024-03-31 07:35:07 浏览: 270
首先,我们使用哈希函数 H(k)=kmod7 将关键字映射到哈希表中的位置。插入关键字时,如果该位置已经被占用,就使用线性探测法向后查找空的位置。
插入关键字 34:
H(34) = 34 mod 7 = 6,将 34 存入哈希表的第 6 个位置。
插入关键字 36:
H(36) = 36 mod 7 = 1,将 36 存入哈希表的第 1 个位置。
插入关键字 20:
H(20) = 20 mod 7 = 6,第 6 个位置已经被占用,向后查找空的位置,发现第 7 个位置为空,将 20 存入第 7 个位置。
插入关键字 16:
H(16) = 16 mod 7 = 2,将 16 存入哈希表的第 2 个位置。
插入关键字 22:
H(22) = 22 mod 7 = 1,第 1 个位置已经被占用,向后查找空的位置,发现第 2 个位置也被占用,继续向后查找,发现第 3 个位置为空,将 22 存入第 3 个位置。
最终得到的哈希表为:
| | 36 | 16 | | | | 20 | 22 |
平均查找长度的计算公式为:ASL = (p1 + 2p2 + 3p3 + ... + npn) / n,其中 pi 表示查找到第 i 个位置的概率,n 表示关键字个数。
对于本题中的哈希表,共有 5 个关键字,每个位置的检索概率相等,均为 1/8。因此,平均查找长度为:
ASL = (1/8 + 2/8 + 3/8 + 4/8 + 5/8) / 5 ≈ 0.9(保留一位小数,末位四舍五入)
相关问题
哈希表 已知哈希表长度为 8,哈希函数为 H(k)=kmod7,采用线性探测法处理冲突。 将下列关键字依次插入到哈希表中, 34, 37, 20, 16, 13 请写出存入数据后的哈希表。
首先,根据哈希函数 H(k)=kmod7,可以得到每个关键字的哈希地址:
- H(34) = 5
- H(37) = 2
- H(20) = 6
- H(16) = 2 (冲突)
- H(13) = 6 (冲突)
因为 16 和 13 的哈希地址与已经插入的关键字冲突,所以需要采用线性探测法解决冲突。
首先,将 34 存储在哈希表的第 5 个位置(因为 H(34) = 5),哈希表变为:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| | | | | |34 | | |
接着,将 37 存储在哈希表的第 2 个位置(因为 H(37) = 2),哈希表变为:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| | |37 | | |34 | | |
然后,将 20 存储在哈希表的第 6 个位置(因为 H(20) = 6),哈希表变为:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| | |37 | | |34 |20 | |
接着,将 16 存储在哈希表的第 3 个位置(因为 H(16) = 2+1 = 3,从第 3 个位置开始向后探测),哈希表变为:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| | |37 |16 | |34 |20 | |
最后,将 13 存储在哈希表的第 4 个位置(因为 H(13) = 6+1 = 7,从第 7 个位置开始向后探测,但因为哈希表长度为 8,所以要回到第 0 个位置继续探测),哈希表变为:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| | |37 |16 |13 |34 |20 | |
因此,最终的哈希表为:{37, 16, 13, 34, 20}。
创建哈希表,设定哈希函数为H(k)=k mod m,输入关键字序列,将其一次存入哈希表中,采用线性探测法处理冲突
好的,这是一个关于哈希表和线性探测法的问题。我会尽力回答。
首先,哈希表是一种数据结构,可以用于快速查找和插入数据。它的基本思想是将数据映射到一个固定大小的数组中,这个映射函数就是哈希函数。在这个问题中,哈希函数是H(k) = k mod m,其中k是关键字,m是哈希表的大小。
线性探测法是一种解决哈希冲突的方法,当两个关键字映射到相同的位置时,线性探测法会依次检查下一个位置,直到找到一个空位置为止。具体来说,如果H(k) = i已经被占用了,那么就检查H(k) = i+1,H(k) = i+2,以此类推,直到找到一个空位置或者回到了起始位置。
下面是一个实现哈希表和线性探测法的示例代码(使用Python语言):
```python
class HashTable:
def __init__(self, size):
self.size = size
self.table = [None] * size
def hash(self, key):
return key % self.size
def insert(self, key):
index = self.hash(key)
while self.table[index] is not None:
index = (index + 1) % self.size
self.table[index] = key
def search(self, key):
index = self.hash(key)
while self.table[index] is not None:
if self.table[index] == key:
return True
index = (index + 1) % self.size
return False
```
在这个代码中,我们首先定义了一个HashTable类,它有一个大小为size的数组和一个哈希函数hash。插入操作通过线性探测法来处理冲突,当找到一个空位置时,就将关键字存入该位置。搜索操作也通过线性探测法来查找关键字,如果找到了就返回True,否则返回False。
希望这个回答对你有帮助!
阅读全文
相关推荐















