转载自：白话算法(6) 散列表(Hash Table)从理论到实用（上）
处理实际问题的一般数学方法是，首先提炼出问题的本质元素，然后把它看作一个比现实无限宽广的可能性系统，这个系统中的实质关系可以通过一般化的推理来论证理解，并可归纳成一般公式，而这个一般公式适用于任何特殊情况。
——R.A. Fisher
在一个解决方案的复杂性之中，理论或者概念的部分通常只占有限的一小部分。理论无法做实际的工作——否则它也不成其为理论了。从理论到实用，需要经过一系列的发明。从实用到更加实用、更加通用，往往需要增加更多的复杂性。有时，这一过程远远超越科学的范畴，成为艺术家的乐园。有时，这一过程引入了过多不必要的复杂性，只是因为人类的自私、愚蠢和目光短浅。
科学不会也不能处理奇迹。科学只能处理重复的事件，艺术却不同。艺术是“就是如此”。在一个创作诞生以前，它是 Nothing——它没有来由、毫无征兆；诞生之后，它就是存在，是合理，是自然和美。我们所谈论的算法，作为一门实用的科学，既有科学的一面，也有艺术的一面。作为科学，它的结构可以分析，它的行为可以预测，它的属性可以量化，它的正确性可以证明。作为艺术，在一个算法诞生之后，有时我们只能说“它能工作”，仅此而已；对于它是如何来到这个世界上的，我们一无所知——这里没有“因为……所以……”，也不是简单的从一般到特殊。创造，似乎和生命一般神秘。我们可以给造物穿上漂亮的科学外衣，欣赏它内在的一致性，但是，最让人着迷的创造性的那一部分，却完全无法加以描述。
所以，当我们进行散列表的从理论到实用之旅时，如果你察觉到一些没有解释的跨越，请不要见怪吧。如果没有这些跨越，我们就完全可以设计一个程序发明这些算法，我们所要学习的算法也就完全会是另外一个样子了。
O(n) 查找和 O(1) 查找，两个模型
如果想知道在《伊利亚随笔选》这本书里是否有一个“囿”字，该怎么做呢？我们只有从第一页的第一行开始，一个字一个字地向后看去，直到找到这个字为止。如果直到最后一页的最后一个字都没有找到它，我们就知道这本书里根本没有这个字。所以，这项工作的复杂度是 O(n)。
再假设有这样一本《会计专用字帖》，它只有9页，每一页上有一个大写的数字：
当会计想要练习“柒”字时，只要她事先知道页码和内容的对应关系，就可以直接翻到第7页，实现 O(1) 复杂度的查找。通过这个模型我们知道，要想达成 O(1) 复杂度的查找，必须满足3个条件：
1. 存储单元（例如一页纸）中存储的内容（例如大写数字）与存储单元的地址（例如页码）必须是一一对应的。
2. 这种一一对应的关系（例如大写数字“柒”在第7页）必须是可以预先知道的。
3. 存储单元是可以随机读取的。这里“随机读取”的意思是可以以任意的顺序读取每个存储单元，并且每次读取所需时间都是相同的。与此相对的，读取磁带里的一首歌就不是随机的——想听第5首歌就不如听第一首歌来得那么方便。
在计算机上实现 O(1) 查找
先来看计算机的硬件设备。计算机的内存支持随机存取，从它的名字 RAM(random-access memory) 可以看得出对于这一点它还真有一点引以为傲呢。
既然硬件支持，我们就可以准备在计算机上模拟会计专业字帖了。第一项任务是向操作系统申请9个存储单元。这里有个小问题，我们得到的存储单元的地址很可能并不是从1到9，而是从134456开始的。好在我们并不需要直接跟操作系统打交道，高级语言会为我们搞定这些琐事。当我们使用高级语言创建一个数组时，相当于申请了一块连续的存储空间，数组的下标是每个存储单元（抽象）的地址。这样我们第一个 O(1) 复杂度的容器 SingleIntSet 很容易就可以完成了，它只能存储 0～9 这10个数字：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public class SingleIntSet
{ private object[] _values = new object[10];
public void Add(int item)
{
_values[item] = item;
}
public void Remove(int item)
{
_values[item] = null;
}
public bool Contains(int item)
{
if (_values[item] == null)
return false;
else
return (int)_values[item] == item;
}
} |
测试一下：
|
1
2
3
4
5
6
7
8
|
static void Main(string[] args)
{ SingleIntSet set = new SingleIntSet();
set.Add(3);
set.Add(7);
Console.WriteLine(set.Contains(3)); // 输出 true
Console.WriteLine(set.Contains(5)); // 输出 false
} |
新术语：使用高级语言创建了一个整型数组时（例如 int[] values = new int[10]），我们不再把 values[7] 称为“一个存储单元”，因为存储单元的大小是一个字节，在32位操作系统上，values[7] 的大小是4字节，所以我们要使用一个新术语，把 values[7] 称为 values 数组的一个槽(slot)。
SingleIntSet2（说实话我真不喜欢这个名字，谁会喜欢？！）
新需求！同样只需要保存10个数字，只不过这次不是保存0～9，而是需要保存10～19，怎么办？很简单，实现一个槽里的值与地址的映射函数 H() 即可：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class SingleIntSet2
{ private object[] _values = new object[10];
private int H(int value)
{
return value - 10;
}
public void Add(int item)
{
_values[H(item)] = item;
}
public void Remove(int item)
{
_values[H(item)] = null;
}
public bool Contains(int item)
{
if (_values[H(item)] == null)
return false;
else
return (int)_values[H(item)] == item;
}
} |
测试的时候，使用10～19范围内的数字：
|
1
2
3
4
5
6
7
8
|
static void Main(string[] args)
{ SingleIntSet2 set = new SingleIntSet2();
set.Add(13);
set.Add(17);
Console.WriteLine(set.Contains(13)); // 输出 true
Console.WriteLine(set.Contains(15)); // 输出 false
} |
房子不够住，难道睡马路？
这次，还是存储10个数字，只不过数字的范围是0～19。如何把20个数字存放到10个槽里？还能怎么办，2人住1间咯。略微修改一下 H() 函数，其它代码不变：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class SingleIntSet3
{ private object[] _values = new object[10];
private int H(int value)
{
if (value >= 0 && value <= 9)
return value;
else
return value - 10;
}
// ...
} |
测试一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
static void Main(string[] args)
{ SingleIntSet3 set = new SingleIntSet3();
set.Add(3);
set.Add(17);
Console.WriteLine(set.Contains(3)); // 输出 true
Console.WriteLine(set.Contains(17)); // 输出 true
Console.WriteLine(set.Contains(13)); // 输出 false
set.Add(13);
Console.WriteLine(set.Contains(13)); // 输出 true
Console.WriteLine(set.Contains(3)); // 输出 false. 但是应该输出 true 才对！
} |
最后一行的结果不对！2人住1间是行不通的，数据受不了这委屈。但是米有办法，除非 1) 我们预先知道所有的10个输入；2) 这10个输入一旦决定就不再更改，否则无论怎么设计 H() 函数都无法避免2人住一间的情况，这时我们就说发生了碰撞（collision）。
用链接法处理碰撞
处理碰撞最简单的一个办法是链接法(chaining)。链接法就是让发生碰撞的2人住2间，但是共用1个公共地址。为了简单起见，可以让数组的每个槽都指向一个链表：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
public class SingleIntSet4
{ private object[] _values = new object[10];
private int H(int value)
{
if (value >= 0 && value <= 9)
return value;
else
return value - 10;
}
public void Add(int item)
{
if (_values[H(item)] == null)
{
LinkedList<int> ls = new LinkedList<int>();
ls.AddFirst(item);
_values[H(item)] = ls;
}
else
{
LinkedList<int> ls = _values[H(item)] as LinkedList<int>;
ls.AddLast(item);
}
}
public void Remove(int item)
{
LinkedList<int> ls = _values[H(item)] as LinkedList<int>;
ls.Remove(item);
}
public bool Contains(int item)
{
if (_values[H(item)] == null)
{
return false;
}
else
{
LinkedList<int> ls = _values[H(item)] as LinkedList<int>;
return ls.Contains(item);
}
}
} |
测试一下，这次得到了正确的结果：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
static void Main(string[] args)
{ SingleIntSet4 set = new SingleIntSet4();
set.Add(3);
set.Add(17);
Console.WriteLine(set.Contains(3)); // 输出 true
Console.WriteLine(set.Contains(17)); // 输出 true
Console.WriteLine(set.Contains(13)); // 输出 false
set.Add(13);
Console.WriteLine(set.Contains(13)); // 输出 true
Console.WriteLine(set.Contains(3)); // 输出 true
} |
如何让21亿人使用10个地址？
好吧，有了链接法，我们有了足够的房子以应对可能发生的碰撞。但是我们仍然希望碰撞发生的几率越小越好，特别是当我们把数值范围由 0～19 扩大到 0～int.MaxValue 时候。有什么办法能把21亿个数值映射成10个数值，并且尽量减少碰撞？
除法散列法
h(k) = k mod m
其中，k为槽中的数值，m是数组的大小（为了简单起见本例中固定为10）。这样我们得到第一个正整数范围内通用的 IntSet：
|
1
2
3
4
5
6
7
8
9
10
|
public class IntSet
{ private object[] _values = new object[10];
private int H(int value)
{
return value % 10;
}
// 其它部分与 SingleIntSet4 相同
} |
测试一下 IntSet.H() 工作得怎么样：
|
1
2
3
|
Console.WriteLine(H(3)); // 输出 3
Console.WriteLine(H(13)); // 输出 3
Console.WriteLine(H(17)); // 输出 7
|
挖藕，只发生了一次碰撞！它竟然与手写版的 SingleIntSet4.H() 工作得一样好。除法散列法为什么有效呢？魔术一旦揭开谜底总是显得平平无奇：
其一，如果小学课程还想得起来的话，应该还记得再大的数除以10的余数都一定介于0～9之间，以此作为下标访问数组自然不用担心越界啦。
其二，让 h() 得出 1 的 k 的数量与让 h() 得出 2 的 k 的数量相同，这样才不容易产生碰撞。
其三，让 h() 得出 1 的 k 是 1、11、21、31……101、111、121……也就是说导致碰撞的 k 值比较分散。这是很重要的，因为在实际使用 IntSet 的时候，存储的值经常是紧挨着的，譬如年龄、序号、身份证号码等等。
需要注意的是 m 不应是 2 的幂即 2p 的形式，此时 h(k) 将等于 k 的二进制的最低 p 位。以 m = 23 = 8 为例，如下图所示：
以 k = 170 为例，h(k) = 170 mod 8 = (27 + 25 + 23 + 0*22 + 21 + 0*20) mod 23 = (24*23 + 22*23 + 23 + 0*22 + 21 + 0*20) mod 23 = 0*22 + 21 + 0*20
也就是说只有最低的 p 位不能被 2p 整除。这有什么问题呢？问题是我们不想假设 k 的分布，所以通常希望 h(k) 的值依赖于 k 的所有位而不是最低 p 位。天知道 k 不会是“11010000、00110000、10010000……” 这种样子（假设有个白痴操作系统喜欢先在高位分配一个对象的 Id，而我们又希望把这个 Id 作为 k 的时候，杯具就发生了）。
当用户指定数组的大小之后，我们要找到一个与之最接近的质数作为实际的 m 值，为了速度，我们把常用的质数预存在一张质数表中，新的 IntSet2 允许用户指定它的容量：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
public class IntSet2
{ private object[] _values;
public IntSet2(int capacity)
{
int size = GetPrime(capacity);
_values = new object[size];
}
private int H(int value)
{
return value % _values.Length;
}
// 质数表
private readonly int[] primes = {
3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369};
// 判断 candidate 是否是质数
private bool IsPrime(int candidate)
{
if ((candidate & 1) != 0) // 是奇数
{
int limit = (int)Math.Sqrt(candidate);
for (int divisor = 3; divisor <= limit; divisor += 2) // divisor = 3、5、7...candidate的平方根
{
if ((candidate % divisor) == 0)
return false;
}
return true;
}
return (candidate == 2); // 除了2，其它偶数全都不是质数
}
// 如果 min 是质数，返回 min；否则返回比 min 稍大的那个质数
private int GetPrime(int min)
{
// 从质数表中查找比 min 稍大的质数
for (int i = 0; i < primes.Length; i++)
{
int prime = primes[i];
if (prime >= min) return prime;
}
// min 超过了质数表的范围时，探查 min 之后的每一个奇数，直到发现下一个质数
for (int i = (min | 1); i < Int32.MaxValue; i += 2)
{
if (IsPrime(i))
return i;
}
return min;
}
// 其它部分与 IntSet 相同
} |
注：质数表 primes 和 IsPrime()、GetPrime() 函数都是 Copy 自 .net framwork2.0 源代码的 Hashtable.cs
乘法散列法
h(k) = ⌊m(kA mod 1)⌋
其中，A 是一个大于0小于1的常数，例如可以取 A = 2654435769 / 232。kA mod 1 的意思是取 kA 的小数部分。C# 代码可以像这样：
|
1
2
3
4
5
|
private readonly double A = 2654435769 / Math.Pow(2, 32);
int H(int value)
{ return (int)(_values.Length * (value * A % 1));
} |
关于那个神奇数字的来历以及如何利用计算机的位操作更快地实现 H()，可参见《算法导论》 P138。
乘法散列法的缺点是不如除法散列法那么均匀，可以比较一下 k 取 0～1000 满足 m = 100，h(k)=1 的 k 的分布：
除法散列法，h(k) = k mod 100k h(k) 跨度1 1 -101 1 100201 1 100301 1 100401 1 100501 1 100601 1 100701 1 100801 1 100901 1 100 |
乘法散列法，h(k) = 100*(kA mod 1)k h(k) 跨度34 1 -123 1 89178 1 55267 1 89411 1 144500 1 89644 1 144733 1 89788 1 55877 1 89 |
到目前为止，还有3个遗憾：
1. 只支持正整数。
2. 链接法虽然简单、直接，却不是处理碰撞的唯一的方法。人家 .net framework 的 Hashtable 可是用的更好的开放寻址法。
3. 只能在创建时指定容器的大小，不能自动扩张。
让我们喘口气先，这些留在下一篇继续战斗。