《算法导论》第三版第11章 散列表 练习&思考题 个人答案

11.1 直接寻址表

11.1-1

解：

DIRECT-ADDRESS-FINDMAX(T)
for i = T.length - 1 to 0
    if T[i] != NIL
        return T[i]

最坏情况$O(m)$。

11.1-2

思路：1代表存在，0代表不存在；插入置位，删除复位。

11.1-3

思路：可以将寻址表的每一个元素指向包含相同关键字的一个双向循环链表。再使用第10章的相关知识完成。

11.1-4

解（来自参考答案）：
We denote the huge array by $T$ and, taking the hint from the book, we also have a stack implemented by an array $S$. The size of $S$ equals the number of keys actually stored, so that $S$ should be allocated at the dictionary’s maximum size. The stack

has an attribute $S.top$, so that only entries $S[1..S.top]$ are valid.
The idea of this scheme is that entries of $T$ and $S$ validate each other. If key $k$ is

actually stored in $T$, then $T[k]$ contains the index, say $j$, of a valid entry in $S$, and

$S[j]$ contains the value $k$. Let us call this situation, in which $1\le T[k]\le S.top$, $S[T[k]]=k$, and $T[S[j]]=j$, a validating cycle.
Assuming that we also need to store pointers to objects in our direct-address table, we can store them in an array that is parallel to either $T$ or $S$. Since $S$ is smaller than $T$, we’ll use an array $S^{\prime }$, allocated to be the same size as $S$, for these pointers. Thus, if the dictionary contains an object $x$ with key $k$, then there is a validating cycle and $S^{\prime }[T[k]]$ points to $x$.
The operations on the dictionary work as follows:

Initialization: Simply set $S.top=0$, so that there are no valid entries in the stack.
SEARCH: Given key $k$, we check whether we have a validating cycle, i.e., whether $1\le T[k]\le S.top$ and $S[T[k]]=k$. If so, we return $S^{\prime }[T[k]]$, and otherwise we return $\text{NIL}$.
INSERT: To insert object $x$ with key $k$, assuming that this object is not already in the dictionary, we increment $S.top$, set $S[S.top]=k$, set $S^{\prime }[S.top]=x$, and set $T[k]=S.top$.
DELETE: To delete object $x$ with key $k$, assuming that this object is in the dictionary, we need to break the validating cycle. The trick is to also ensure that we don’t leave a “hole” in the stack, and we solve this problem by moving the top entry of the stack into the position that we are vacating-and then fixing up that entry’s validating cycle. That is, we execute the following sequence of assignments:

$$\begin{array}{rl}& S[T[k]]=S[S.top]\\ & S^{\prime }[T[k]]=S^{\prime }[S.top]\\ & T[S[T[k]]]=T[k]\\ & T[k]=0\\ & S.top=S.top-1\end{array}$$
Each of these operation - initialization, $\text{SEARCH}$, $\text{INSERT}$, and $\text{DELETE}$-takes $O(1)$ time.

11.2 散列表

11.2-1

解：对不相同的kl组合求1/m的和，可得$\frac{n(n-1)}{2m}$。

11.2-2

解：中间过程略，最后结果是
0
1→10→19→28
2→20
3→12
4
5→5
6→33→15
7
8→17

11.2-3

解：
查找：期望时间不变，但查找的值越大所需时间越多（如果是单链表升序排列的话）
插入：期望时间不变，所需时间略多（需要执行一次时间复杂度是$O(1)$的插入操作）
删除：期望时间不变，但删除的值越大所需时间越大（如果是单链表升序排列的话）

11.2-4

思路：标志位用来标志该槽位是否被占用，如果没有被占用，两个指针分别指向前一个和后一个空槽位（如同一个双向链表）；如果被占用，一个指针指向保存的元素。
解（来自参考答案）：
The flag in each slot will indicate whether the slot is free.
（每个插槽中的标志将指示插槽是否空闲。）
A free slot is in the free list, a doubly linked list of all free slots in the table. The slot thus contains two pointers.
A used slot contains an element and a pointer (possibly $\text{NIL}$) to the next element that hashes to this slot. (Of course, that pointer points to another slot in the table.)
（空闲插槽位于空闲列表中，空闲列表是表中所有空闲插槽的双向链表。因此，槽包含两个指针。已使用的插槽包含一个元素和一个指向下一个散列到此插槽的元素的指针（可能是$\text{NIL}$）。（当然，该指针指向表中的另一个插槽。））
Operations（操作）

Insertion（插入）:

If the element hashes to a free slot, just remove the slot from the free list and store the element there (with a $\text{NIL}$ pointer). The free list must be doubly linked in order for this deletion to run in $O(1)$ time.

If the element hashes to a used slot $j$, check whether the element $x$ already there “belongs” there (its key also hashes to slot $j$).

If so, add the new element to the chain of elements in this slot. To do so, allocate a free slot (e.g., take the head of the free list) for the new element and put this new slot at the head of the list pointed to by the hashed-to slot ($j$).
If not, $E$ is part of another slot’s chain. Move it to a new slot by allocating one from the free list, copying the old slot’s ($j$'s) contents (element $x$ and pointer) to the new slot, and updating the pointer in the slot that pointed to $j$ to point to the new slot. Then insert the new element in the now-empty slot as usual.

To update the pointer to $j$, it is necessary to find it by searching the chain of elements starting in the slot $x$ hashes to.

Deletion（删除）:
Let $j$ be the slot the element $x$ to be deleted hashes to.

If $x$ is the only element in $j$ ($j$ doesn’t point to any other entries), just free the slot, returning it to the head of the free list.
If $x$ is in $j$ but there’s a pointer to a chain of other elements, move the first pointed-to entry to slot $j$ and free the slot it was in.
If $x$ is found by following a pointer from $j$, just free $x$'s slot and splice it out of the chain (i.e., update the slot that pointed to $x$ to point to $x$'s successor).

Searching（查找）:
Check the slot the key hashes to, and if that is not the desired element, follow the chain of pointers from the slot.
All the operations take expected $O(1)$ times for the same reason they do with the version in the book: The expected time to search the chains is $O(1+\alpha )$ regardless of where the chains are stored, and the fact that all the elements are stored in the table means that $\alpha \le 1$. If the free list were singly linked, then operations that involved removing an arbitrary slot from the free list would not run in $O(1)$ time.

11.2-5

这不是很显然吗。。$\frac{|U|}{m}>n$必然至少有一个槽中有多于n个的元素，鸽笼原理？

11.2-6

思路：最长链长度为L，共有m条链，可以看成一个m行L列的矩阵，只要调用RANDOM(1, m)和RANDOM(1, L)，直到找到一个包含元素的位置，需要mL/n（即L/α）次，再查找该元素即可。

11.3 散列函数

11.3-1

思路：比较链表中元素的散列值和给定关键字的散列值。

11.3-2

解：

sum = 0
for i = 1 to r
    sum = (sum *128 + s[i]) mod m // 使用sum作为散列值

11.3-3

解（来自参考答案）：
First, we observe that we can generate any permutation by a sequence of interchanges of pairs of characters. One can prove this property formally, but informally, consider that both heapsort and quicksort work by interchanging pairs of elements and that they have to be able to produce any permutation of their input array. Thus, it suffices to show that if string $x$ can be derived from string $y$ by interchanging a single pair of characters, then $x$ and $y$ hash to the same value.
（首先，我们观察到我们可以通过一系列字符交换生成任何排列。可以正式地证明这个属性，但是非正式地，考虑堆排序和快速排序都可以通过交换元素对来工作，并且他们必须能够产生输入数组的任何排列。因此，足以证明如果字符串$x$可以通过交换一对字符从字符串$y$派生，那么$x$和$y$将散列到相同的值。）
Let us denote the $i$th character in $x$ by $x_i$, and similarly for $y$. The interpretation of $x$ in radix $2^p$ is ${\sum }_{i=0}^{n-1}{x}_i{2}^{ip}$, and so $h(x)=({\sum }_{i=0}^{n-1}{x}_i{2}^{ip})\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)$. Similarly, $h(y)=({\sum }_{i=0}^{n-1}{y}_i{2}^{ip})\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)$.
Suppose that $x$ and $y$ are identical strings of $n$ characters except that the characters in positions $a$ and $b$ are interchanged: $x_a=y_b$ and $y_a=x_b$. Without loss of generality, let $a>b$. We have
$$h(x)-h(y)=\left(\sum _{i=0}^{n-1}{x}_i{2}^{ip}\right)\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)-\left(\sum _{i=0}^{n-1}{y}_i{2}^{ip}\right)\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1).$$
Since $0\le h(x)$, $h(y)<2^p-1$, we have that $-(2^p-1)<h(x)-h(y)<2^p-1$. If we show that $(h(x)-h(y))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)=0$, then $h(x)=h(y)$.
Since the sums in the hash functions are the same except for indices $a$ and $b$, we have
$$\begin{array}{rl}(h(x)-h(y))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)& =((x_a{2}^{ap}+x_b{2}^{bp})-(y_a{2}^{ap}+y_b{2}^{bp}))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)\\ & =((x_a{2}^{ap}+x_b{2}^{bp})-(x_b{2}^{ap}+x_a{2}^{bp}))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)\\ & =((x_a-x_b)2^{ap}-(x_a-x_b)2^{bp})\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)\\ & =((x_a-x_b)(2^{ap}-2^{bp}))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)\\ & =((x_a-x_b)2^{bp}(2^{(a-b)p}-1))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1).\end{array}$$
By equation $\text{(A.5)}$,
$$\sum _{i=0}^{a-b-1}{2}^{pi}=\frac{2^{(a-b)p}-1}{2^p-1},$$
and multiplying both sides by $s^p-1$, we get $2^{(a-b)p}-1=\left({\sum }_{i=0}^{a-b-1}{2}^{pi}\right)(2^p-1)$. Thus,
$$\begin{array}{rl}(h(x)-h(y))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)& =((x_a-x_b)2^{bp}(\sum _{i=0}^{a-b-1}{2}^{pi})(2^p-1))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)\\ & =0,\end{array}$$
since one of the factors is $2^p-1$.
We have shown that $(h(x)-h(y))\mathrm{m}\mathrm{o}\mathrm{d}(2^p-1)=0$, and so $h(x)=h(y)$.

11.3-4

解：
$h(61)=700$
$h(62)=318$
$h(63)=936$
$h(64)=554$
$h(65)=172$

11.3-5

解（来自参考答案）：
Let $b=|B|$ and $u=|U|$. We start by showing that the total number of collisions is minimized by a hash function that maps $u/b$ elements of $U$ to each of the $b$ values in $B$. For a given hash function, let $u_j$ be the number of elements that map to $j\in B$. We have u=∑j∈Buju = \sum_{j \in B} u_j