采用哈希函数并用H（k）=2*k mod 13链地址法处理冲突，在数列地址空间[0～12]中对关键字序列22，41 53 46 30 13 1 6 17 51求哈希表

### 回答1：
这里是一个示例的哈希表：

Index:  0  1  2  3  4  5  6  7  8  9  10  11  12
Key:    -  1  6 13 17 22 30 41 46 51 53  -   -

其中空缺的部分表示空闲空间，"-" 表示没有关键字。

如果存在冲突，可以采用链地址法处理，将冲突的关键字链接在一起。

### 回答2：
哈希函数H(k) = 2*k mod 13，链地址法处理冲突的哈希表如下：

0：
1：1
2：22, 46
3：
4：30
5：
6：6, 53
7：
8：17
9：
10：41
11：
12：51

首先，计算关键字的哈希值。对于关键字序列22，41，53，46，30，13，1，6，17，51，分别进行哈希运算，得到的哈希值为：

H(22) = 2*22 mod 13 = 9
H(41) = 2*41 mod 13 = 5
H(53) = 2*53 mod 13 = 6
H(46) = 2*46 mod 13 = 1
H(30) = 2*30 mod 13 = 4
H(13) = 2*13 mod 13 = 0
H(1) = 2*1 mod 13 = 2
H(6) = 2*6 mod 13 = 12
H(17) = 2*17 mod 13 = 8
H(51) = 2*51 mod 13 = 10

接下来，根据哈希值将关键字插入哈希表的对应位置。如果哈希值对应的位置为空，则直接插入关键字；如果不为空，则通过链地址法将关键字插入到对应位置的链表末尾。最终得到的哈希表如上所示。

注意：哈希函数和哈希表的具体实现方式可能因编程语言或数据结构的不同而有所差异，上述回答仅为描述一种常见的求解过程。

### 回答3：
采用哈希函数H(k) = 2*k mod 13，并使用链地址法处理冲突，对关键字序列22，41，53，46，30，13，1，6，17，51进行哈希表的构建。

首先，创建13个空链表，用来存放哈希表中的值。

然后，按照哈希函数的计算方式，对关键字序列进行哈希表的构建：

1. 对关键字22进行哈希，计算得到H(22) = 2*22 mod 13 = 8。将22插入到哈希表的第8个链表中。

2. 对关键字41进行哈希，计算得到H(41) = 2*41 mod 13 = 10。将41插入到哈希表的第10个链表中。

3. 对关键字53进行哈希，计算得到H(53) = 2*53 mod 13 = 4。将53插入到哈希表的第4个链表中。

4. 对关键字46进行哈希，计算得到H(46) = 2*46 mod 13 = 7。将46插入到哈希表的第7个链表中。

5. 对关键字30进行哈希，计算得到H(30) = 2*30 mod 13 = 4。将30插入到哈希表的第4个链表中。

6. 对关键字13进行哈希，计算得到H(13) = 2*13 mod 13 = 0。将13插入到哈希表的第0个链表中。

7. 对关键字1进行哈希，计算得到H(1) = 2*1 mod 13 = 2。将1插入到哈希表的第2个链表中。

8. 对关键字6进行哈希，计算得到H(6) = 2*6 mod 13 = 12。将6插入到哈希表的第12个链表中。

9. 对关键字17进行哈希，计算得到H(17) = 2*17 mod 13 = 11。将17插入到哈希表的第11个链表中。

10. 对关键字51进行哈希，计算得到H(51) = 2*51 mod 13 = 12。将51插入到哈希表的第12个链表中。

最后的哈希表为：
下标 0: 13
下标 1:
下标 2: 1
下标 3:
下标 4: 53 -> 30
下标 5:
下标 6:
下标 7: 46
下标 8: 22
下标 9:
下标 10: 41
下标 11: 17
下标 12: 6 -> 51
其中，->表示链表的指针指向下一个元素。