{29,01,13,15,56,20,87,27,69,9,10,74},散列函数为：h(key)=key % 17,采用平方5.6测方法解决冲突。试在0到18的散列地址空间中对该关键字序列构造散列表。

### 回答1：
首先，根据散列函数h(key)=key % 17，我们可以得到这些关键字对应的散列地址：

- 29：12
- 01：1
- 13：13
- 15：15
- 56：5
- 20：3
- 87：4
- 27：10
- 69：4
- 09：9
- 10：10
- 74：8

其中，20和69的散列地址冲突了，需要采用平方5.6的方法解决冲突。

具体地，我们将所有关键字都插入到散列表中，如果发现冲突，就按照如下算法重新计算散列地址，直到找到一个空槽：

new_hash = (old_hash + i * i) % table_size

其中，`old_hash`是原来的散列地址，`i`从1开始递增，直到找到一个空槽或者尝试次数超过了散列表的大小。

因此，我们可以按照以下步骤构造散列表：

1. 创建一个大小为18的散列表，所有槽初始化为空。
2. 将关键字29插入到槽12中。
3. 将关键字01插入到槽1中。
4. 将关键字13插入到槽13中。
5. 将关键字15插入到槽15中。
6. 将关键字56插入到槽5中。
7. 将关键字20插入到槽3中，发现与关键字69冲突。
8. 采用平方5.6的方法解决冲突，重新计算散列地址：new_hash = (3 + 1 * 1) % 18 = 4。将关键字20插入到槽4中。
9. 将关键字87插入到槽4中，发现与关键字20冲突。
10. 采用平方5.6的方法解决冲突，重新计算散列地址：new_hash = (4 + 1 * 1) % 18 = 5。将关键字87插入到槽5中。
11. 将关键字27插入到槽10中。
12. 将关键字69插入到槽4中，发现与关键字20和87都冲突。
13. 采用平方5.6的方法解决冲突，重新计算散列地址：
- new_hash = (4 + 1 * 1) % 18 = 5，与87冲突。
- new_hash = (4 + 2 * 2) % 18 = 8，插入成功。将关键字69插入到槽8中。
14. 将关键字09插入到槽9中。
15. 将关键字10插入到槽10中，发现与关键字27冲突。
16. 采用平方5.6的方法解决冲突，重新计算散列地址：
- new_hash = (10 + 1 * 1) % 18 = 11，插入成功。将关键字10插入到槽11中。
17. 将关键字74插入到槽8中，发现与关键字69冲突。
18. 采用平方5.6的方法解决冲突，重新计算散列地址：
- new_hash = (8 + 1 * 1) % 18 = 9，插入成功。将关键字74插入到槽9中。

最终，我们得到的散列表如下：

0:
1: 01
2:
3: 20
4: 87
5: 56
6:
7: 29
8: 69 74
9: 09
10: 27
11: 10
12: 29
13: 13
14:
15: 15
16:
17:

注意，在平方5.6的方法中，每次递增的$i$值可以是$1, 2, 3, \ldots, (table\_size-1)/2$。但由于本题中散列表的大小为18，因此最大的$i$值为8，即尝试次数最多为9次。如果尝试次数超过了这个值，就说明散列表已经满了。

### 回答2：
根据给定的散列函数和冲突解决方法，我们可以按照以下步骤构造散列表：

1. 创建一个大小为19的散列表（0到18的散列地址空间），用None填充。

2. 对于给定的关键字序列 {29,01,13,15,56,20,87,27,69,9,10,74}，依次计算散列值并插入散列表中。

- 对于关键字29，计算散列值 h(29) = 29 % 17 = 12，将关键字29插入散列表的索引12位置。若无冲突，则结束此次插入。

- 对于关键字01，计算散列值 h(01) = 1 % 17 = 1，将关键字01插入散列表的索引1位置。若无冲突，则结束此次插入。

- 对于关键字13，计算散列值 h(13) = 13 % 17 = 13，将关键字13插入散列表的索引13位置。若无冲突，则结束此次插入。

- 对于关键字15，计算散列值 h(15) = 15 % 17 = 15，将关键字15插入散列表的索引15位置。若无冲突，则结束此次插入。

- 对于关键字56，计算散列值 h(56) = 56 % 17 = 5，发生冲突。根据平方探测法，根据hash值的正负，探测序列为[5, 8, 13, 2, 16, 12, 9, 14, 3, 7]。从索引5开始探测，直到找到一个空位置（None），将关键字56插入该位置。

- 对于关键字20，计算散列值 h(20) = 20 % 17 = 3，将关键字20插入散列表的索引3位置。若无冲突，则结束此次插入。

- 对于关键字87，计算散列值 h(87) = 87 % 17 = 4，将关键字87插入散列表的索引4位置。若无冲突，则结束此次插入。

- 对于关键字27，计算散列值 h(27) = 27 % 17 = 10，将关键字27插入散列表的索引10位置。若无冲突，则结束此次插入。

- 对于关键字69，计算散列值 h(69) = 69 % 17 = 4，发生冲突。根据平方探测法，探测序列为[4, 9, 1, 16, 8, 7, 0, 3, 12, 15]。从索引4开始探测，直到找到一个空位置（None），将关键字69插入该位置。

- 对于关键字9，计算散列值 h(9) = 9 % 17 = 9，将关键字9插入散列表的索引9位置。若无冲突，则结束此次插入。

- 对于关键字10，计算散列值 h(10) = 10 % 17 = 10，发生冲突。根据平方探测法，探测序列为[10, 15, 3, 1, 14, 6, 13, 16, 4, 7]。从索引10开始探测，直到找到一个空位置（None），将关键字10插入该位置。

- 对于关键字74，计算散列值 h(74) = 74 % 17 = 8，将关键字74插入散列表的索引8位置。若无冲突，则结束此次插入。

最终的散列表为：[None, 01, 13, 74, 87, 56, 69, 20, 74, 9, 10, 27, 29, None, 15, None, 27, None, 01]
其中None表示空位置。

### 回答3：
根据散列函数h(key)=key % 17，可以计算出关键字序列{29,01,13,15,56,20,87,27,69,9,10,74}的散列地址。
29 % 17 = 12，该关键字散列地址为12；
01 % 17 = 1，该关键字散列地址为1；
13 % 17 = 13，该关键字散列地址为13；
15 % 17 = 15，该关键字散列地址为15；
56 % 17 = 5，该关键字散列地址为5；
20 % 17 = 3，该关键字散列地址为3；
87 % 17 = 5，由于地址5已被占用，使用平方5.6测方法解决冲突：5+0*0^2 = 5，地址5被占用，再次平方：5+1*1^2 = 5，地址5还是被占用，再次平方：5+2*2^2 = 9，地址9没有被占用，所以该关键字散列地址为9；
27 % 17 = 10，该关键字散列地址为10；
69 % 17 = 4，该关键字散列地址为4；
9 % 17 = 9，由于地址9已被占用，使用平方5.6测方法解决冲突：9+0*0^2 = 9，地址9被占用，再次平方：9+1*1^2 = 9，地址9还是被占用，再次平方：9+2*2^2 = 9，地址9还是被占用，再次平方：9+3*3^2 = 0，地址0没有被占用，所以该关键字散列地址为0；
10 % 17 = 10，由于地址10已被占用，使用平方5.6测方法解决冲突：10+0*0^2 = 10，地址10被占用，再次平方：10+1*1^2 = 10，地址10还是被占用，再次平方：10+2*2^2 = 14，地址14没有被占用，所以该关键字散列地址为14；
74 % 17 = 8，该关键字散列地址为8。

根据以上计算，关键字序列{29,01,13,15,56,20,87,27,69,9,10,74}对应的散列表为：
0: 9
1: 01
2:
3: 20
4: 69
5: 56
6:
7: 87
8: 74
9:
10: 27
11:
12: 29
13: 13
14: 10
15: 15
16:

其中，空白处表示没有对应的关键字。