skywang12345

导航

统计
 

 

转载自:白话算法(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*2+ 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 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


到目前为止,还有3个遗憾:
1. 只支持正整数。
2. 链接法虽然简单、直接,却不是处理碰撞的唯一的方法。人家 .net framework 的 Hashtable 可是用的更好的开放寻址法。
3. 只能在创建时指定容器的大小,不能自动扩张。

让我们喘口气先,这些留在下一篇继续战斗。  

posted on 2013-09-10 11:57  如果天空不死  阅读(...)  评论(...编辑  收藏