选取哈稀函数 H ( K )=(3k) MOD 11。用开放定址法处理冲突， di = i ( i =1,2, 3,…)．试在0-10的散列地址空间中对关键字序列(22,41,53,46,30,13,01,67)造哈希表哈希查找方法。

首先，将关键字序列中的每个关键字都通过哈希函数 H(K)=(3K) mod 11 映射到散列表中的某个地址，得到的映射结果如下：

| 关键字 K | 哈希地址 H(K) |
| -------- | ------------ |
| 22 | 8 |
| 41 | 2 |
| 53 | 7 |
| 46 | 9 |
| 30 | 8 |
| 13 | 6 |
| 01 | 3 |
| 67 | 10 |

其中，哈希地址 H(K) 的计算公式为 H(K) = (3K) mod 11。

由于存在冲突，需要使用开放定址法来解决。假设散列表的长度为 m=11，则根据开放定址法，冲突解决的公式为：

di = i (i=1,2,3,...)

即，如果第一次哈希地址 H(K) 已经被占用，则线性探测下一个地址，直到找到一个空闲的地址为止。

因此，对于上述关键字序列，我们可以按照如下方式将它们插入到散列表中：

1. 将关键字 22 插入到地址 8 处，得到的散列表为：

| 地址 | 关键字 |
| ---- | ------ |
| 0 | |
| 1 | |
| 2 | |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 | 22 |
| 9 | |
| 10 | |

2. 将关键字 41 插入到地址 2 处，得到的散列表为：

| 地址 | 关键字 |
| ---- | ------ |
| 0 | |
| 1 | |
| 2 | 41 |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 | 22 |
| 9 | |
| 10 | |

3. 将关键字 53 插入到地址 7 处，得到的散列表为：

| 地址 | 关键字 |
| ---- | ------ |
| 0 | |
| 1 | |
| 2 | 41 |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | 53 |
| 8 | 22 |
| 9 | |
| 10 | |

4. 将关键字 46 插入到地址 9 处，得到的散列表为：

| 地址 | 关键字 |
| ---- | ------ |
| 0 | |
| 1 | |
| 2 | 41 |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | 53 |
| 8 | 22 |
| 9 | 46 |
| 10 | |

5. 将关键字 30 插入到地址 8 处，由于地址 8 已经被占用，因此需要线性探测下一个地址。下一个地址为 9，但是该地址已经被占用。继续线性探测下一个地址，下一个地址为 10，该地址为空闲，因此将关键字 30 插入到地址 10 处。得到的散列表为：

| 地址 | 关键字 |
| ---- | ------ |
| 0 | |
| 1 | |
| 2 | 41 |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | 53 |
| 8 | 22 |
| 9 | 46 |
| 10 | 30 |

6. 将关键字 13 插入到地址 6 处，得到的散列表为：

| 地址 | 关键字 |
| ---- | ------ |
| 0 | |
| 1 | |
| 2 | 41 |
| 3 | |
| 4 | |
| 5 | |
| 6 | 13 |
| 7 | 53 |
| 8 | 22 |
| 9 | 46 |
| 10 | 30 |

7. 将关键字 01 插入到地址 3 处，得到的散列表为：

| 地址 | 关键字 |
| ---- | ------ |
| 0 | |
| 1 | |
| 2 | 41 |
| 3 | 01 |
| 4 | |
| 5 | |
| 6 | 13 |
| 7 | 53 |
| 8 | 22 |
| 9 | 46 |
| 10 | 30 |

8. 将关键字 67 插入到地址 10 处，由于地址 10 已经被占用，因此需要线性探测下一个地址。下一个地址为 0，但是该地址已经被占用。继续线性探测下一个地址，下一个地址为 1，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 2，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 3，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 4，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 5，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 6，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 7，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 8，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 9，但是该地址也已经被占用。继续线性探测下一个地址，下一个地址为 10，但是该地址也已经被占用。此时，散列表已经被填满，无法再插入新的关键字。

因此，最终得到的散列表为：

| 地址 | 关键字 |
| ---- | ------ |
| 0 | 67 |
| 1 | 01 |
| 2 | 41 |
| 3 | 01 |
| 4 | |
| 5 | |
| 6 | 13 |
| 7 | 53 |
| 8 | 22 |
| 9 | 46 |
| 10 | 30 |

可以看到，通过开放定址法解决冲突后，每个关键字都被成功地插入到了散列表中，并且查找时也可以通过哈希函数快速定位到对应的位置，从而实现了快速查找。