散列表（HashTable）探秘--上

作者：书友36296361 | 来源：互联网 | 2023-05-19 01:16

处理实际问题的一般数学方法是，首先提炼出问题的本质元素，然后把它看作一个比现实无限宽广的可能性系统，这个系统中的实质关系可以通过一般化的推理来论证理解，并可归纳成一般公式，而这个一般公式适用于任何特殊

处理实际问题的一般数学方法是，首先提炼出问题的本质元素，然后把它看作一个比现实无限宽广的可能性系统，这个系统中的实质关系可以通过一般化的推理来论证理解，并可归纳成一般公式，而这个一般公式适用于任何特殊情况。
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——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个数字：

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;
    }
}

测试一下：

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() 即可：

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范围内的数字：

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() 函数，其它代码不变：

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;
    }
    // ...
}

测试一下：

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个公共地址。为了简单起见，可以让数组的每个槽都指向一个链表：

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 ls = new LinkedList();
            ls.AddFirst(item);
            _values[H(item)] = ls;
        }
        else
        {
            LinkedList ls = _values[H(item)] as LinkedList;
            ls.AddLast(item);
        }
    }
    public void Remove(int item)
    {
        LinkedList ls = _values[H(item)] as LinkedList;
        ls.Remove(item);
    }
    public bool Contains(int item)
    {
        if (_values[H(item)] == null)
        {
            return false;
        }
        else
        {
            LinkedList ls = _values[H(item)] as LinkedList;
            return ls.Contains(item);
        }
    }
}

测试一下，这次得到了正确的结果：

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：

public class IntSet
{
    private object[] _values = new object[10];
 
    private int H(int value)
    {
        return value % 10;
    }
    // 其它部分与 SingleIntSet4 相同
}

测试一下 IntSet.H() 工作得怎么样：

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 的幂即 2^p 的形式，此时 h(k) 将等于 k 的二进制的最低 p 位。以 m = 2³ = 8 为例，如下图所示：

以 k = 170 为例，h(k) = 170 mod 8 = (2⁷ + 2⁵ + 2³ + 0*2² + 2¹ + 0*2⁰) mod 2³ = (2⁴*2³+ 2²*2³ + 2³ + 0*2² + 2¹ + 0*2⁰) mod 2³ = 0*2² + 2¹ + 0*2⁰也就是说只有最低的 p 位不能被 2^p 整除。这有什么问题呢？问题是我们不想假设 k 的分布，所以通常希望 h(k) 的值依赖于 k 的所有位而不是最低 p 位。天知道 k 不会是“11010000、00110000、10010000……” 这种样子（假设有个白痴操作系统喜欢先在高位分配一个对象的 Id，而我们又希望把这个 Id 作为 k 的时候，杯具就发生了）。
　　当用户指定数组的大小之后，我们要找到一个与之最接近的质数作为实际的 m 值，为了速度，我们把常用的质数预存在一张质数表中，新的 IntSet2 允许用户指定它的容量：

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         {
            int prime = primes[i];
            if (prime >= min) return prime;
        }
 
        // min 超过了质数表的范围时，探查 min 之后的每一个奇数，直到发现下一个质数
        for (int i = (min | 1); i         {
            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 / 2³²。kA mod 1 的意思是取 kA 的小数部分。C# 代码可以像这样：

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 100
k h(k) 跨度
1 1 -
101 1 100
201 1 100
301 1 100
401 1 100
501 1 100
601 1 100
701 1 100
801 1 100
901 1 100

乘法散列法，h(k) = 100*(kA mod 1)
k h(k) 跨度
34 1 -
123 1 89
178 1 55
267 1 89
411 1 144
500 1 89
644 1 144
733 1 89
788 1 55
877 1 89