设散列表的地址范围是[ 0..9 ]，散列函数为H（key）= （key 2 +2）MOD 9,并采用链表处理冲突，请画出元素7、4、5、3、6、2、8、9依次插入散列表的存储结构。

### 回答1：
这是散列表存储结构图：

[0] -> [2] -> [5] -> [8] -> null
[1] -> [3] -> [6] -> null
[2] -> [4] -> [7] -> null
[3] -> [9] -> null
[4] -> null
[5] -> null
[6] -> null
[7] -> null
[8] -> null
[9] -> null

当元素 7、4、5、3、6、2、8、9 依次插入散列表时，散列表存储结构如下：

[0] -> [2] -> [5] -> [8] -> null
[1] -> [3] -> [6] -> null
[2] -> [4] -> [7] -> null
[3] -> [9] -> null
[4] -> null
[5] -> null
[6] -> null
[7] -> null
[8] -> null
[9] -> null

插入元素 7：

[0] -> [2] -> [5] -> [8] -> null
[1] -> [3] -> [6] -> null
[2] -> [4] -> [7] -> null
[3] -> [9] -> null
[4] -> null
[5] -> null
[6] -> null
[7] -> null -> [7] -> null
[8] -> null
[9] -> null

插入元素 4：

[0] -> [2] -> [5] -> [8] -> null
[1] -> [3] -> [6] -> null
[2] -> [4] -> [7] -> null
[3] -> [9] -> null
[4] -> [4] -> null
[5] -> null
[6] -> null
[7] -> null -> [7] -> null
[8] -> null
[9] -> null

插入元素 5：

[0] -> [2] -> [5] -> [8] -> null
[1] -> [3] -> [6] -> null
[2] -> [4] -> [7] -> null
[3] -> [9] -> null
[4] -> [4] -> null
[5] -> [5] -> null
[6] -> null
[7] -> null -> [7] -> null
[8] -> null
[9] -> null

插入元素 3：

[0] -> [2] -> [5] -> [8] -> null
[1] -> [3] -> [6] -> null
[2] -> [4] -> [7] -> null
[3] -> [9] -> [3] -> null
[4] -> [4] -> null
[5] -> [5] -> null
[6] -> null
[7] -> null -> [7] -> null
[8] -> null
[9] -> null

### 回答2：
根据散列函数H(key) = (key^2) % 9，我们需要将元素7、4、5、3、6、2、8、9依次插入散列表的存储结构。

首先，我们初始化一个长度为10的散列表，每个位置都为空链表。散列表地址范围为[0..9]。

插入元素7：
根据散列函数，计算H(7) = (7^2) % 9 = 49 % 9 = 4。将元素7插入散列表中第4个位置，形成链表节点。

插入元素4：
根据散列函数，计算H(4) = (4^2) % 9 = 16 % 9 = 7。将元素4插入散列表中第7个位置，形成链表节点。

插入元素5：
根据散列函数，计算H(5) = (5^2) % 9 = 25 % 9 = 7。由于第7个位置已经有元素4存在，我们将元素5插入到4后面，形成链表节点。

插入元素3：
根据散列函数，计算H(3) = (3^2) % 9 = 9 % 9 = 0。将元素3插入散列表中第0个位置，形成链表节点。

插入元素6：
根据散列函数，计算H(6) = (6^2) % 9 = 36 % 9 = 0。由于第0个位置已经有元素3存在，我们将元素6插入到3后面，形成链表节点。

插入元素2：
根据散列函数，计算H(2) = (2^2) % 9 = 4 % 9 = 4。由于第4个位置已经有元素7存在，我们将元素2插入到7后面，形成链表节点。

插入元素8：
根据散列函数，计算H(8) = (8^2) % 9 = 64 % 9 = 1。将元素8插入散列表中第1个位置，形成链表节点。

插入元素9：
根据散列函数，计算H(9) = (9^2) % 9 = 81 % 9 = 0。由于第0个位置已经有元素3和6存在，我们将元素9插入到6后面，形成链表节点。

综上所述，元素7、4、5、3、6、2、8、9依次插入散列表后的存储结构如下：
0 -> 3 -> 6 -> 9
1 -> 8
2 ->
3 ->
4 -> 7 -> 2
5 ->
6 ->
7 -> 4 -> 5
8 ->
9 ->

每个位置对应的链表节点即为在该位置上进行散列后得到的元素。

### 回答3：
散列函数 H(key) = (key^2) MOD 9

散列表的地址范围为[ 0..9 ]

元素7：H(7) = (7^2) MOD 9 = 4；将元素7插入地址4处。
地址4：7 -> NULL

元素4：H(4) = (4^2) MOD 9 = 7；将元素4插入地址7处。
地址4：7 -> NULL
地址7：4 -> NULL

元素5：H(5) = (5^2) MOD 9 = 7；发生冲突，将元素5插入地址7处的链表尾部。
地址4：7 -> NULL
地址7：4 -> 5 -> NULL

元素3：H(3) = (3^2) MOD 9 = 0；将元素3插入地址0处。
地址0：3 -> NULL
地址4：7 -> NULL
地址7：4 -> 5 -> NULL

元素6：H(6) = (6^2) MOD 9 = 0；发生冲突，将元素6插入地址0处的链表尾部。
地址0：3 -> 6 -> NULL
地址4：7 -> NULL
地址7：4 -> 5 -> NULL

元素2：H(2) = (2^2) MOD 9 = 4；发生冲突，将元素2插入地址4处的链表尾部。
地址0：3 -> 6 -> NULL
地址4：7 -> 2 -> NULL
地址7：4 -> 5 -> NULL

元素8：H(8) = (8^2) MOD 9 = 1；将元素8插入地址1处。
地址0：3 -> 6 -> NULL
地址1：8 -> NULL
地址4：7 -> 2 -> NULL
地址7：4 -> 5 -> NULL

元素9：H(9) = (9^2) MOD 9 = 0；发生冲突，将元素9插入地址0处的链表尾部。
地址0：3 -> 6 -> 9 -> NULL
地址1：8 -> NULL
地址4：7 -> 2 -> NULL
地址7：4 -> 5 -> NULL

最终的散列表存储结构如下：
地址0：3 -> 6 -> 9 -> NULL
地址1：8 -> NULL
地址2：NULL
地址3：NULL
地址4：7 -> 2 -> NULL
地址5：NULL
地址6：NULL
地址7：4 -> 5 -> NULL
地址8：NULL
地址9：NULL