博客园_一个程序员的自省

迷人的斐波那契数

2012-04-18T16:31:00Z

繁殖力超强的兔子

说到斐波那契数，我们自然会想到曾经有一群繁殖力超强的兔子。比萨的商人斐波那契（Fibonacci，12-13世纪，称为比萨的列奥那多）接触到阿拉伯数学后，在其著作《Liber Abaci》中，引入了这个著名的兔子问题。但如果向前追溯下去，则可以追溯到古老的印度数学。斐波那契使用了一个理想化了的兔子生长模型进行研究，并假设：

第一个月初有一对刚诞生的兔子
两个月之后(第三个月初)它们可以生育
每月每对可生育的兔子会诞生下一对新兔子
兔子永不死去

从第一个月开始，兔子的数目（对）依次是：1，1，2，3，5，8。。。这样就形成了一个序列，记为{Fn}，则该序列存在一个递推关系：F(n)=F(n-1)+F(n-2)，n >= 3。可以通过如下简单的推断得出：F(n)表示在第n个月时兔子的对数，这些兔子分为两部分，一是在第n-1个月已有的兔子，因为它们都活了下来（实际上会一直活下去），也就是F(n-1)；二是F(n-1)对兔子中可生育的兔子，也就是已经生活了至少二个月的兔子，这个数字恰好是在第n-2个月已有的兔子，即F(n-2)。如果令F(0)=0，则F(n)的定义可推广至所有非负整数（公式一）：

F(0)=0
F(1)=1
F(n) = F(n-1) + F(n-2)，当n > 1

递归求值

这看起来是个非常简单的递推关系，若要通过程序求值，很自然地，可通过递归实现（算法一）：

// 递归算法 by Anders Cui
public int Fib(int n)
{
if (n <= 1) { return n; }

return Fib(n - 1) + Fib(n - 2);
}

很多书籍在讲解递归求解时，也常常会选择斐波那契数作为例子。这个例子是一个很直观的递归应用，也很有趣，但却算不上一个好的应用。比如，求F(5)时可表示为下图：

即使对5这样小的数进行求值，也可以看到一点儿端倪，F(3)、F(2)都要多次求值，如果n的值很大，那么其中计算的冗余就非常多了。想办法来改进一下，最直接的办法就是要重用每一项之前的项，这样计算每一项时只需要一次加法。比如，要计算F(n)，就创建一个长度为n+1的数组，逐一计算每一项，F(n)的时间复杂度和空间复杂度都是O(n)，这是动态规划的应用。进一步地，按上面的方法，我们创建了一个长度为n+1的数组，但实际上每次运算只会涉及到三个相邻的元素，这就意味着只需要三个变量就可以维护所需要的值了，从而可以将空间复杂度降低到O(1)（算法二）：

// 算法二 by Anders Cui
public static int Fib(int n)
{
if (n <= 1) { return n; }

int previousButOne = 0;
int previous = 1;
int answer = 1;

for (int i = 2; i < n; i++)
{
previousButOne = previous;
previous = answer;
answer = previousButOne + previous;
}

return answer;
}

那有没有更高效的算法？别忘了，本文的主题是斐波那契序列，在考虑序列时，往往需要分析它的通项公式，如果能找出它的通项公式，那么就可以快速得出答案了。

斐波那契序列的通项公式

前面提到F(n)的递推公式是F(n) = F(n-1) + F(n-2)，即F(n) - F(n-1) - F(n-2) = 0，这是一个所谓“带常系数的齐次二阶线性递推式”，由其特征方程及初始值F(0)和F(1)，可以求出通项公式为（过程略）：

这个公式令人称奇之处在于，通过无理数的乘方表示出了一个整数序列的所有元素！通过此公式还可以确定F(n)是呈指数级增长的。不管怎样，根据通项公式可以在O(1)时间内得到答案（算是算法三吧），但计算机不能完全精确地表示无理数，从而无法保证计算的精度。

不过一旦有了通项公式，研究兔子序列时就方便多了。下面将讨论算法一（递归算法）的效率。

在使用递归进行计算的时候，算法的基本操作无疑就是加法。用A(n)表示计算F(n)时所需要的加法次数，则在n>1时，有A(n) = A(n-1) + A(n-2) + 1，与F(n)递推式不同，这是一个非齐次递推式，其求解方法有所不同，不过对于这里的A(n)，却可以快速解出。将上式变形为：

[A(n) + 1] - [A(n-1) + 1] - [A(n-2) + 1] = 0，

如果令B(n) = A(n) + 1，则B(n) - B(n-1) - B(n-2) = 0，B(0) = 1，B(1) = 1。到这里可以发现，B(n)与F(n)递推式相同，不过前者从1,1开始，后者从0,1开始，即B(n) = F(n+1)。所以A(n) = F(n+1) - 1，从而得出A(n)也为指数级。这是斐波那契序列的另一个奇妙之处：通过自身的通项公式了解自身的计算特点。

性质、变形与应用

斐波那契序列有为数众多的有趣性质，甚至有专门讨论它的杂志，这里不再赘述。

由本文开头的递推关系给出，其中两个要素是递推关系和初始值。如果对这两个要素进行调整，就可以得到其它相关的序列，如卢卡斯数、反斐波那契数等等。另外，斐波那契数不仅仅是一个数字谜题，它也有很多应用，这里仅给出两个例子。

爬梯子

假设每一步可以爬一格或者两格梯子，爬一部n格梯子一共可以用几种不同的方法？（比如三格的梯子有三种不同的爬法：1-1-1，1-2，2-1）

在分析这个问题的时候，也可以考虑用递归。假设爬n格梯子有A(n)种不同的方法，第一步要么爬一格，此时剩下的格子爬完共有A(n-1)种；要么爬两格，此时剩下的格子爬完共有A(n-2)种，从而得到递推关系A(n) = A(n-1) + A(n-2)，初始值为A(1) = 1，A(2) = 2。可以看出A(n)与F(n)的关系是：A(n) = F(n + 1)，n > 0。

F(n)在很多这样的组合题中都有应用，另外F(n)的一个组合证明可以看这里。

欧几里德算法（求最大公约数）的效率分析

欧几里德算法据说是史上第一个算法，这两个古老的算法也有重要的交集。首先给出F(n)的一个性质（可通过数学归纳法证明）：

然后通过辗转相除法的定义和F(n)的这个性质可以证明：欧几里德算法求解GCD(a, b)时使用的除法次数不大于b的十进制位数的5倍。再由对数的性质可以得出欧几里德算法使用O(logb)次除法就可以求出GCD(a, b)。

（涉及很多公式书写，这里证明从略，具体过程可参考《离散数学及其应用》的3.4节）

另一个算法

F(n-1)、F(n)和F(n+1)的关系也可以用矩阵表示出来：

这里n > 0，这样F(n)的计算可以转化为右边矩阵的乘方，而这个过程的时间复杂度是O(logn)，所以这是一个不错的选择。

小结

斐波那契序列有很多迷人的性质和有趣的应用，本文仅为匆匆一瞥，希望能让你对它多一些兴趣。总之，繁殖力超群的兔子们在欢乐的繁殖着，而“兔子问题”也没闲着，吸引着人们对它不断地研究，并得到了广泛应用。

参考

《算法设计与分析基础》
《编程之美》
斐波那契数
 Fibonacci Number

本文链接

趣题一则：交替放置的碟子

2012-04-16T13:43:00Z

有数量为2n的一排碟子，n黑n白交替放置。现在要把黑碟子都放在右边，白碟子都放在左边，但只允许通过交换相邻碟子的位置来实现。实现这个过程要交换多少次？

分析

首先把问题转化一下，用1表示黑碟子，0表示白碟子，那么目前的顺序是：

1010...1010

结果要求1都放在右边，0都放在左边。这个题目看起来很眼熟。看关键字：交换相邻的碟子，排好顺序。嗯，就是经常出现在面试中的冒泡排序了。

为便于观察，假设目前有6个碟子：101010。使用冒泡排序，第一次迭代，碟子序列变为：010101，交换3次。在进行第二次迭代之前，观察一下。

现在，不仅第一个碟子就位，最后一个也是了，因此第二次迭代只需要对第2到第5个进行排序，巧合的是，碟子[2->5]仍然是10交替出现，不过比上一次少了两个，这样就简单了，可以得到结论：对于2n个碟子，可以使用n次迭代完成，交换的次数分别是：n+(n-1)+...+2+1，即n(n+1)/2。

顺便说一句，对于常见的经典排序算法，要么是简单直观的，如选择排序、插入排序，其实就是平时摸牌时所用的方法；要么是效率较高的，如快速排序、归并排序。我觉得冒泡排序既不直观，也不高效，也许就因为得了一个好名字，就名扬算法界了，所以名字神马的很重要！

参考

《算法设计与分析基础》

本文链接

趣题一则：冯·诺依曼邻居问题

2012-04-14T16:51:00Z

这里并不是真的要研究cellular automaton的问题，而只是考虑一个非常简单的递推关系，该问题如下图所示：从r=0开始，此时格子上有一个方块，然后逐步演化，每一步都在上一步的基础上添加一圈儿方块，当r=n时，会有多少个方块呢？分析假设初始方块为O，从r=0到r=1时，在O的水平和垂直方向上各增加了两个方块；从r=1到r=2时，也是如此，同时在其它方向上也增加了若干方块。由此，可以把方块的增加分为两部分，一是水平和垂直方向D1，二是其它方向D2。可以看到，每到新的一步，D1方向上增加的都是4个方块，它们都与原图（上一步）的一个边相邻；而D2方向上增加的方块都与原图的两条边相邻。这样，只

趣题一则：寻找那扇门

2012-04-10T15:51:00Z

现在出现在你面前的是一堵朝两个方向无限延伸的墙。墙上有一扇门，但你并不确定门离你有多远，也不知道门位于哪个方向（左边或是右边）。你只有在走到门面前才能看到它。假设从当前位置到门要走n步（n大小未知），那么怎样走O(n)步就能找到那扇门？

分析

这道题让人“左右为难”，因为不确定如何才能走到尽快确定方向和位置。首先想到在错误的方向上走得越远，就意味着离正确的位置越远，因此较为保险的方法是，第一步向右走，看看有没有门；第二步——为了防止在错误的方向上渐行渐远——向左走，走两步，这样就可以确定在最初位置的一步范围内有没有门了。

接下来，按照类似的方式左右徘徊，依次确定在最初位置的2，3，...，n有没有门了。不过，直觉上就会知道走了很多冤枉路，很可能不是O(n)了。下面来具体计算一下。

假设T(n)为按上述方法确定出左右各n步范围内是否有门所需要的步数，那么

T(1) = 2 + 1

T(2) = T(1) + 2*2 + 1

T(3) = T(2) + 2*3 + 1

...

T(n) = T(n-1) + 2*n + 1

两边相加，得T(n) = n^2 + 2*n，看来这个方法太慢了。

为了更好地分析慢的原因，我们从另一个角度来看上面的方法。将寻找门的过程看作一个个回合，初始位置标记为O，第一回合向右走一步，回到O，向左走一步，回到O；第二回合向右走二步，回到O，向左走二步，回到O；。。。；第n回合向右走n步，回到O，向左走n步，回到O。这样总的步数是4*(1+2+...+n)=2(n^2+n)。每个回合仅比上一回合多一步，造成的结果就是大量的重复。但如果考虑一种极端的情况，第一回合向右走n步，回到O，向左走n步，共n步，由于不知道n的大小，这算不上是一种有效的方法，但它说明，如果我们每个回合间的跨度够大，确实有可能达到O(n)。

在常见的渐进效率类型中，比多项式明显要大的是指数级，如2^n，这里先考察这种情况。即第i回合向右走2^i步，回到O，向左走2^i步，回到O，这里0<=i<=k且2^(k-1)<n<=2^k。这样经过k个回合就可以找到门的位置，总的步数是：

可以看到，这种新的回合制是符合要求的。接下来也许可以尝试更大的跨度，如3^n或n!甚至是n*n!，这里先不讨论了。

参考：

《算法设计与分析基础》

本文链接

HashSet的实现（下）

2011-06-17T09:19:00Z

在HashSet的实现（上）中，简要介绍了散列法（hashing）的内容，并以二次探测法实现了一个简单的HashSet。在本文中，将进一步讨论散列法，尤其是GetHashCode方法的实现，最后给出完整的HashSet实现。

散列法再议

通过散列法实现的容器，不管是HashSet、Hashtable还是Dictionary，需要支持的基本操作是insert、remove和find，特别是insert和find，三个操作的时间复杂度期望是O(1)。

散列法的使用过程中，主要有两个问题：

散列函数的实现；
冲突的解决办法；

下面将在上篇的基础上进一步讨论这两个问题的解决方案。

散列函数的实现

一般情况下，要存储的元素（key/k）类型可能有多种，可能取值的集合为K，它的个数为，实际需要insert的个数为n。现在要把这些元素存放在大小为M的数组内，这样我们就需要一个函数h:K -> {0, 1, …, M-1}，它可以将元素k映射到数组的一个有效下标，这个函数就是所谓的散列函数（hashfunction），可以记为h(k,M)。一个好的散列函数需要具备如下特性：

容易计算（主要是指散列函数的时间复杂度为常数时间）。
将元素均匀地映射到数组中，减少冲突的可能；

进一步，可以将h(k,M)视为如下两个函数f、g的复合函数：

f和g对h需要具备的两个特性，都会有所影响。

g将f返回的一个int值映射到{0, 1, …, M-1}，常规方法是除法散列法（DivisionMethod），即g(k)= k % M。在应用除法散列法时，需要主要M值的选取。比如，M不应是2的幂，如果M=，则 k % M的值就是k的二进制表示的p个最低位数字，要满足特性2，可能就会有问题了。可以选做M的值常常是与2的幂不太接近的素数。除了除法散列法，还可以选择乘法散列法（Multiplication Method）：。可分为两步，第一步，用k乘上常数A（0<A<1），取出kA的小数部分，即kA mod 1；第二步，用M乘以小数部分，取其下取整。

相比较而言，f的实现要复杂很多。首先，用作key的值的类型多种多样，包括各种自定义类型，另一方面要考虑h的两个特性。大体上，可以将f对应于object.GetHashCode()方法。默认情况下，每个类型从object（引用类型）或ValueType（值类型）继承了一个GetHashCode的实现。如果我们将h的两个特性与特定的.NET平台结合起来考虑，实现GetHashCode()的时候需要如下几个规则（rule）：

计算简单；
产生的int值应当是均匀分布的；
如果两个对象相等（由==操作符确定），它们必须产生相同的hashCode；
对于任意一个对象o，o.GetHashCode()的返回值应当是一个实例不变量，即总是返回相同的值。

接下来就来详细地讨论如何实现GetHashCode()方法。

实现GetHashCode()方法

既然每个类型都从object（引用类型）或ValueType（值类型）继承了一个GetHashCode的实现，那还有必要自己实现吗？可以确定的是，没有一种完美的实现可以应用于所有类型，否则一个object.GetHashCode()方法就够了。因为object和ValueType对其派生类的可能信息一无所知，所以它们只能提供一个可用的实现，而未必是最佳的。

对于引用类型来说，它继承了object.GetHashCode()，该方法返回在AppDomain内可以唯一标识该对象的值，在对象的整个生命周期内，该值是不变的，但经过垃圾收集之后，这个值可以复用到其它的对象。这个值也等于RuntimeHelpers.GetHashCode()方法的返回值，即使我们为某个类型提供了自己的GetHashCode()实现，RuntimeHelpers.GetHashCode()方法的返回值仍然是那个默认的值。

对于引用类型，默认的==会检查两个对象的引用（identity），如果相等，必然会返回相等的值；而一旦重写了==操作符，就需要同时重写GetHashCode，否则编译器会警告你的。现在看一下上面的f要满足的4个规则，object.GetHashCode()可以满足1、3、4，但规则2未必能满足，它产生的值倾向于使用int的较低位（这个结论来自《Effective C#》，未验证），所以说，object.GetHashCode()是可用的，但可能会在使用Hash容器时出现性能问题。当你创建了新的引用类型，并确定会用做Hash容器的key的话，最好重写GetHashCode方法。

对于值类型来说，它继承了ValueType.GetHashCode()，该方法用到了反射，所以比较慢。关于具体的实现，《CLR via C#》中说是对类型的某些实例字段做了XOR操作，《Effective C#》中说是返回了第一个字段的GetHashCode()。经过测试，应该说ValueType.GetHashCode()是由第一个字段的GetHashCode()决定的，但不相等。ValueType的问题要比object更严重。对于规则1，上面说过，由于反射会比较慢；规则2，说一个极端点儿的情况，如果第一个字段是bool类型的，那会出现怎样的悲剧？；规则3，还是一样，如果重写了==，必须要同时重写GetHashCode()。

对于规则4，就很可能有问题了。对于一个值类型的实例，它的hashCode取决于第一个字段，如果第一个字段是可修改的，一旦修改，hashCode的值也就改变了。当我们把key加入到Hash容器时它的hashCode是h1，如果后来改成h2，就意味着原来的实例找不到了。。。

总结下来，object.GetHashCode()对引用类型来说是一个正确的实现，但不一定会产生均匀分布的hashCode，GetHashCode必须与==同时重写；ValueType.GetHashCode()较慢，而且仅在第一个字段只读、能提供均匀分布的hashCode时可用。如果在计算hashCode时用到了3个字段，这3个字段应该都要参与到==的实现里；参与到hashCode计算的字段或属性最好设置为只读的。

最好还是看看在.NET Framework中GetHashCode是怎么实现的。

FCL中GetHashCode的实现

1 // 32位的int
2 public override int GetHashCode()
3 {
4 return this;
5 }
6
7 // 16位的char
8 public override int GetHashCode()
9 {
10 return (int)(this | (int)this << 16);
11 }
12
13 // 64位的long
14 public override int GetHashCode()
15 {
16 return (int)this ^ (int)((int)this >> 32);
17 }

整数类型的实现是最简单的，需要在int内均匀分布，所以像char这样的，要补足32位（通过<<），同时要用到所有的位（像long这样的实现，会用到64位的每一位）。对于复合的值类型，可考虑如下方法：

1 // 值类型：System.Drawing.Point
2 public override int GetHashCode()
3 {
4 return this.x ^ this.y;
5 }

对若干字段进行^操作。

对于最常用作key的string类型，它的GetHashCode实现比较复杂，具体的分析可以看这里。唔，关于散列函数h的讨论就先到这里了。

冲突的解决办法

上篇曾介绍过两种方法：线性探测法和二次探测法，它们和更好的双重散列法都属于开放寻址法的范畴，只是探测序列的分布有所不同。在开放寻址法中，所有的元素（key）都放在散列数组本身中，插入新元素时，通过探测序列找到它的合适位置。

而在分离链接法中，把散列到同一槽（slot）的元素都放在一个链表中，这样散列数组存放的只是相对应链表的指针而已，借助于链表，分离链接法实现起来其实更简单，它不需要花费很多心思在那个探测序列的选择上。

可以看到，要对散列法、散列函数有全面的认识，为类型提供良好的GetHashCode()实现都不是容易的事情。最好的办法还是借助于ILSpy这样的反编译工具去看一下FCL中HashSet<T>、Dictionary<K, V>和Hashtable的实现，园子里有些这方面的文章。关于Hash，就到这里，余下的部分将讨论ISet的实现。

ISet接口简介

ISet<T>继承了IEnumerable<T>和ICollection<T>，前面讨论过的insert、find、remove操作对应ICollection<T>的Add、Contains和Remove方法。ISet<T>本身的方法几乎都是（除了Add）关于两个集合间的操作的，比如求交集、并集、差集，判断是否是另一集合的子集等等，这些实现起来不难，差不多就是把集合操作的定义搬过来就行了，这里就不再赘述了。

根据《数据结构与问题求解Java语言描述》和FCL的HashSet<T>代码写了一个简单的HashSet实现，没有经过严格的测试，可以当作伪代码来参考一下:)

参考

《数据结构与问题求解》
《算法导论》
《CLR via C#》
《Effective C#》
Hash Function
Hash Table
string.GetHashCode()
ILSpy

本文链接

HashSet的实现（上）

2011-06-12T18:03:00Z

要理解HashSet，可以按字面上把它分解为两部分，一方面它表示一个集合（Set），另一方面，它的实现使用了散列法（Hashing）。

集合（Set）

还记得吗？在中学里曾经学过，集合是某些指定对象的全体，集合的三个性质是确定性、互异性和无序性。本文提到的集合正是这个数学概念在计算机中的实现。

说到集合，可能你会想到Collection这个词，以及.NET中的ICollection<T>接口，它们通常也被解释为“集合”，不过它们和Set有明显的不同。Collection可以看作是一组数据项的容器（Container），它与数学中的集合概念无关。同时，Set是一种特殊的容器。也就是说，Set的概念更强一些。在本文余下的部分，用集合表示Set，容器表示Collection和Container。

这里比较值得关注的是互异性，在开发中有些时候需要这样的一个容器。我们经常使用的数组和List<T>本身不能满足该性质。.NET3.5之前没有一个类型是直接提供这种支持的，一种方案是采用Hashtable或Dictionary，在存储数据项的时候，只使用key，value忽略。.NET3.5（以及以上）提供了HashSet<T>泛型类，终于可以满足集合的要求了。

集合作为一种数据结构，它的主要操作很简单，最重要的是添加和移除元素，以及查询（判断某个值是否在集合中，枚举集合中的所有元素）。要实现一个集合类型，首先可以使用简单的数组，但是数组元素查询的时间复杂度是O(n)；比数组好得多的另一个选择是二叉搜索树，它本身就提供了上述的三个操作，而且速度都很快：O(logn)，这种实现一般称为TreeSet。二叉搜索树在操作的时候需要维护元素之间的相对顺序，而集合对顺序是没有要求的，是否可以提供更好的时间复杂度呢？

答案就是HashSet，相关的方法是散列法（Hashing），这也是本文的主要内容。关于集合更详细的讨论（泛型接口ISet<T>，集合之间的操作，如交集、并集等）将在下篇中进行。

散列法

现在再来明确一下目标。我们要实现的Set类要满足元素的互异性，但不关心元素的顺序如何；要支持的操作是添加(insert)元素、移除(remove)元素、查询(find)（判断某个值是否在集合中）；每种操作的时间复杂度要比O(logn)好。

对于数组来说，如果知道了下标，那么访问该元素的时间复杂度为O(1)，现在看能否利用这一点。考虑一种简单情况，我们要处理的集合包含若干小的整数，范围在0到99之间，并且事先可以确定集合的元素个数不会超过100。此时，可以创建一个长度为100的int数组a，其元素全部初始化为0。对于一个数i，要完成insert(i)操作，只要执行a[i] = 1；对于remove(i)操作，只需要a[i] = 0；find(i)操作，可以返回a[i] == 1（或a[i] > 0）。

三种操作的时间复杂度都是O(1)，实现起来也很简单，看起来不错。不过它有两个明显的问题，如果要保存的整数不是一个小范围内的值，而是所有int，那么数组a的长度要超过40亿，太不现实；另外，我们要实现的是泛型类，可以容纳各种类型的值，如果不是int，而是string，元素本身的值不能用作索引。

上面的两个问题也是散列法的两个核心问题。先来看第二个问题：对于非整型的值，如何获得它对应的数组下标。以string为例，假设它包含的字符都是ASCII字符，对应的int值范围是0-127。对于“junk”，可以这样来计算：'j'*128^3 + 'u'*128^2 + 'n'*128^1 + 'k'*128^0，这样就把一个string值转换为int值了。不过这种方法会产生巨大的整数，对于“junk”这样简单的字符串，产生的值就高达224229227，可以想见，对于复杂一点儿的字符串将是不能接受的。于是又回到了上段中的第一个问题，如何避免使用过于巨大的数组？

如果集合的元素是int类型，虽然int的可能值超过40亿，但是在一个特定的问题中，集合的元素个数却可能很有限。如果元素个数不超过1000，那么只需要一个长度为1000的数组就够了，如果一个值超过了数组下标的上限，可以通过一个函数将该值映射到0-999，这样的函数称为散列函数（hash function）。

散列函数

根据上面的分析，对于一个集合S，用来存放元素的数组长度为tableSize，其中的任一元素e，散列函数h将e映射到0到tableSize之间的一个整数（即数组的一个有效索引），可以记为：

index = h(e, tableSize)

首先针对元素e，根据某种特定的方法计算出它的int值hashCode，然后返回hashCode % tableSize，这样返回值就会落在0到tableSize-1之间。显然，在散列函数的实现中，最重要的部分就是计算hashCode。你也许已经想到了一个方法，那就是object.GetHashCode()，这里需要的正是它。该方法是virtual的，这样它的每个子类都可以提供自己的实现。比如下面的例子：

（图片来自wikipedia，将string类型的值映射到tableSize为16的数组上。）

前面提到过，很多情况下，元素e的取值范围要比tableSize大得多，这样就有可能遇到一种情况，对于不同的两个元素e1和e2，有h(e1, tableSize) == h(e2, tableSize)，此时它们被映射到同一个数组索引，这种复杂的情况称为冲突（collision），在本文后面会讨论如何解决冲突问题。

一般地，一个好的散列函数需要满足：

容易计算（主要是指散列函数的时间复杂度为常数时间）。
将元素均匀地映射到数组中，减少冲突的可能；

如果元素类型是基元类型，可以使用它们内置的GetHashCode实现，对于自定义类型的实现，将会在下篇中进行讨论。

当冲突发生时

现在我们已经有了散列函数，接下来需要确定当冲突发生时如何化解它。具体来说，如果一个元素e，经过散列函数求值，被散列到的位置已经被另一个元素占据，那么e应该放在哪里？

最简单的方法是，下一个位置。在数组中顺序搜索，直到找到一个空位置。为利用数组的所有空位置，搜索进行到数组尾部时，可以绕回到第一个位置。这种方法就是线性探测法（linear probing）。

考虑一个例子，数组长度tableSize = 10，要添加的元素是89、18、49、58和9。散列函数的返回结果为：

hash(89, 10) → 9
hash(18, 10) → 8
hash(49, 10) → 9
hash(58, 10) → 8
hash(9, 10) → 9

索引	insert(89)	insert(18)	insert(49)	insert(58)	insert(9)
0			49	49	49
1				58	58
2					9
3
4
5
6
7
8		18	18	18	18
9	89	89	89	89	89

在添加89和18时，没有冲突。添加49时，与89冲突，寻找下一个空位置，由于到达数组尾部，绕回，在索引0处存放49；接下来的58和9与此类似。只要数组足够大，就可以找到一个空位置。但问题是，“探测”的时间可能会很长，如果只有一个空位置，那么要搜遍整个数组才能找到，平均下来要搜索半个数组，这与我们的每个操作都是常数时间的期望已经相去甚远了。

再来看find操作，它的探测路径与insert相同。要找58，从索引8（hash的返回值）开始，这个位置有一个元素，但不是58；继续向下看索引9，仍然不是，直到索引1，找到了匹配的元素。要找19，从索引9开始，历经9、0、1、2，最后到了一个空位置3，这说明数组中没有与之匹配的项。

最后是remove操作，不能直接将元素删除（将该位置置空）。从上面分析可以看到，insert和find操作都需要一条探测路径，如果直接删除，就会打断这条路径，从而使find操作失效。如果把89直接删除，那么49、58和9就都找不到了。

线性探测法的简单分析

在上面的例子中，向空的数组添加元素时没有冲突，到后来冲突越来越多，这也是符合我们的直觉的。公交车上越拥挤，冲突发生的可能性就越大。在散列法中有一个专门的术语：负载因子（load factor）。探测散列表的负载因子λ是表被装满的比例，范围从0（空）到1（满）。

使用线性探测法时，比较容易产生连续被占据的块，如果一个元素被散列到这个块中，就需要连续尝试以找到下一个可用位置（看上面添加9时）。这种连续聚集的块称为初始聚集（primary clustering）。用线性探测法添加项时，需要尝试的平均单元数大约是。

如果λ=0.5，尝试次数为2.5，还是可以的；如果λ=0.9，那么尝试次数就多达50次了（这还是平均数，某些情况比这更糟）。

对于find操作来说，可以分为两种情况：不成功的和成功的。不成功的情况与insert操作一样。如果查找成功，需要检查的平均单元数约为。

如果λ=0.5，尝试次数为1.5；如果λ=0.9，尝试次数为5.5。

看来λ=0.5是个不错的选择，平均探测次数很少，也不会需要大量的空闲位置，而且很容易实现。不过，为了减少探测数，我们需要一种能避免初始聚集的方法，一种选择就是二次探测法。

二次探测法（quadratic probing）

在线性探测法中，当发现冲突产生时，我们会从冲突位置开始顺序探测下一个可用位置，这正是产生初始聚集的原因。如果散列函数hash的返回值为h，那么探测的位置将依次是h + 1，h + 2，...，h + i。探测的位置连续，当然就容易产生聚集了。既然这样，就不要探测连续的位置了，记为，现在改为依次探测h + f(1)，h + f(2)，...，h + f(i)。下面来看二次探测法的使用，还是使用前面的那个例子。

hash(89, 10) → 9
hash(18, 10) → 8
hash(49, 10) → 9
hash(58, 10) → 8
hash(9, 10) → 9

索引	insert(89)	insert(18)	insert(49)	insert(58)	insert(9)
0			49	49	49
1
2				58	58
3					9
4
5
6
7
8		18	18	18	18
9	89	89	89	89	89

在添加49时，与89冲突，49的最终位置是(9 + 1) % 10 = 0；添加58时，与18冲突，而(8 + 1)位置与89冲突，所以58的最终位置是(8 + 2^2) % 10 = 2；同理，9的位置是3。这里有个相当重要的地方是，hash值为8的元素和hash值为9的元素探测路径不同，添加58不会影响到后面添加9，这是比线性探测好的地方。

在编码之前，我们再来考虑几个问题，这几个问题解决后，你会发现二次探测法的实现灰常简单。这几个问题是：

使用线性探测法，虽然它可能会比较慢，但它可以保证的是，只要数组不满，就可以插入新的值，二次探测法也可以做到这一点吗？另外，探测路径中的位置会不会被重复探测到？
线性探测法实现只需要简单的计算，二次探测法则需要乘法和模运算，这会不会造成太大的负担？
如果λ过高怎么办？能否动态扩展数组？

对于问题1，如果tableSize为素数，而且λ不超过0.5，就可以解决，即下面的定理：

定理1：如果采用二次探测法并且表（数组）的大小是素数，表至少有一半是空的（即λ <= 0.5），那么新的元素总能插入，插入过程中没有一个位置会被探测两次。

证明：设表的大小为M，M为大于3的奇素数。现在考虑探测序列的前项（包括初始项），可以证明它们彼此是不同的。这里使用反证法。假设这些项的某两个项是和，其中。若这两项相同且，那么

因为M是素数，所以i-j或i+j可以被M整除，因为i和j不同且它们的和小于M，这两种情况都不可能。可以得出，这两项是不同的，由于λ>0.5（M为奇数），所以这项中必然有一项是空位置，这样元素总能插入，且不会有位置被探测两次。

对于问题2，线性探测法需要的计算需要一次简单的加法（加1）、一个确定是否需要绕回表头的测试，一个很少出现的减法（返回表头）。二次探测法需要做一次加法（i – 1到i）、一次乘法（i * i）、一次加法和一次取模，看起来开销很大。通过下面的定理：

定理2：不需要昂贵的乘法和取模就能实现二次探测法。

简单说一下证明。探测序列中的相邻两项是和，那么。

问题3的出现是因为，要解决问题1，我们需要保证λ不超过0.5，随着元素的增加，需要动态扩展数组，这个过程称为重散列（rehashing）。扩展为新的数组后，不能简单的将元素拷贝过去，因为新的tableSize意味着新的散列函数，这里的做法是重新检查原有数组的每个元素，将它们添加到新数组中。

现在可以来考虑HashSet的具体实现了，首先来看HashSet的Hash部分，通过散列法实现Set的三种基本操作。HashSet的类图大致如下：

这里通过嵌套类HashEntry来存放集合中的值，前面提到过，不能够直接删除某个项，而是通过一个IsActive属性进行标识。对于主要的三个操作Add（insert）、Remove和Contains（find）来说，它们都需要一个探测序列来找到insert的位置或是查询是否包含某个值。这个类似的探测过程都放在了FindPos方法中：

1 private int FindPos(T item)
2 {
3 int collisionNum = 0;
4 int pos = (item.IsNull()) ? 0 : Math.Abs(item.GetHashCode() % array.Length);
5
6 while (array[pos].IsNotNull())
7 {
8 if (item.IsNull())
9 {
10 if (array[pos].Item.IsNull())
11 {
12 break;
13 }
14 }
15 else if (item.Equals(array[pos].Item))
16 {
17 break;
18 }
19
20 pos += 2 * (++collisionNum) - 1;
21 if (pos >= array.Length)
22 {
23 pos -= array.Length;
24 }
25 }
26
27 return pos;
28 }

第4行获得初始散列值，第20行使用的是定理2中的公式。

有了FindPos方法，三个操作的代码都变得简单了：

public bool Add(T item)
{
int pos = FindPos(item);
if (IsActive(pos))
{
// Item exists, just return.
return false;
}

array[pos] = new HashEntry<T>(item, true);
currentSize++;
occupied++;
modCount++;

if (occupied > array.Length / 2)
{
Rehash();
}

return true;
}

public bool Remove(T item)
{
int pos = FindPos(item);
if (!IsActive(pos))
{
return false;
}

array[pos].IsActive = false;
currentSize--;
modCount++;

if (currentSize < array.Length / 8)
{
Rehash();
}

return true;
}

public bool Contains(T item)
{
return IsActive(FindPos(item));
}

private bool IsActive(int pos)
{
return array[pos].IsNotNull() && array[pos].IsActive;
}

另外几个需要注意的地方是，默认的tableSize = DEFAULT_TABLE_SIZE = 101，二次探测法要求tableSize为素数。在需要Rehash（扩展和收缩）的时候，也需要保持tableSize为素数。完整的代码在这里(IsNull和IsNotNull只是两个简单的扩展方法，判断某个变量是否为null)。

到这里，我们使用二次探测法实现了HashSet的三个基本操作，不过关于GetHashCode方法和ISet接口的实现，这里还没有提及，这些留在下一篇中进行讨论。

其它冲突解决方法

还有一种流行的方法是分离链接法（separate chaining）：

（图片来自wikipedia）

如上图，John Smith和Sandra Dee都散列到了152位置，它们对应的两个值将形成一个链表，也就是它们被放在了同一个桶（bucket）里，这样的好处是不会大量的“空桶”，从而节省了空间。理解了二次探测法，这个也比较容易理解。

小结

本文主要讨论了散列法和散列函数的基本概念以及解决散列冲突的两种方法：线性探测法和二次探测法，并以二次探测法简单地实现了HashSet的Hash这一部分。在下篇中将会讨论GetHashCode方法在自定义类型中的实现以及给HashSet添加对ISet接口的实现，那样才算是一个真正的Set。

参考

《数据结构与问题求解》
Hash Function
Hash Table

本文链接

趣题一则：如何快速过桥？

2011-06-02T16:31:00Z

有四个人打算过桥，他们都在桥的某一端，他们的任务是在17分钟内全部到达桥的另一头。当时是晚上，他们只有一只手电筒，最多只能有两人同时过桥，因为伸手不见五指，必须要携带手电筒。必须步行将手电筒带来带去，即扔来扔去是不行的。每个人走路的速度是不同的：甲过桥需要1分钟，乙需要2分钟，丙需要5分钟，丁需要10分钟。两个人一起走的速度等于其中较慢的人的速度。例如，如果第一次让甲和丁一起过桥，当他们到桥的另一端时，已经用了10分钟，如果由丁带回手电筒，那么20分钟就过去了，于是任务失败。那他们到底该怎样过去呢？

第一次甲和乙同行，然后乙回去送手电筒，用掉4分钟；下一次丙和丁同行，甲回去，用掉11分钟；最后甲和乙再次同行，用掉2分钟。任务完成。

本文链接

制作自己的wikibook

2011-05-03T13:38:00Z

wikipedia.org是我特别喜欢的网站，首先是它的信息量极为丰富，不管是文章本身的内容，还是它所引用的外部资源；而且文章的风格也很让人喜欢，简约的文本，配以适量的图片，很对我的口味；另外一个重要的地方是，文章内容比较可靠。

如果看到一篇喜欢的wiki文章，想打印出来，那么看页面的左边侧栏：

可以使用Printable版本打印，也可以保存为本地的PDF文件。最有趣的地方是“Create a book”：

一旦开始书籍的创建，在页面的页首部分就会出现一个功能区域：

当我们把需要的文章都添加进来后，点击Show book，即进入书籍的管理页面，甚至还可以组织书籍的章节！然后，可以保存为本地文件，格式可以是PDF、ODT和ZIM。

此外，可以想见，很可能有其他人已经创建了你需要的书籍，wikipedia也提供了搜索功能来搜索书籍，有时可以节省很多时间:)

本文链接

玩儿一下Word Search Puzzle

2011-03-19T16:40:00Z

单词搜索迷宫（Word Search Puzzle）问题的输入是一个二维的字符数组和一组单词，目标是找出字符数组网格中的所有单词。这些单词可以是水平的、垂直的或者是任意的对角线方向，所以需要查找8个不同的方向。如下图的网格：

	0	1	2	3
0	t	h	i	s
1	w	a	t	s
2	o	a	h	g
3	f	g	d	t

这里面共有4个单词：this（[0, 0]-[0, 3]）、two（[0, 0]-[2, 0]）、fat（[3, 0]-[1, 2]）和that（[3, 3]-[0, 0]），其它更短的单词此处没有列出。

问题分析

最直接的方法就是，使用蛮力算法逐一检查每个可能的字符串是否在单词表中，就像我们用眼睛去检查那样，可以描述为：

for each row R
     for each column C
          for each direction D
               check if word W in wordList

假设单词列表wordList有40个单词，16×16的网格，需要大约80000（16*16*8*40）次检查，这种方法还是可行的。但如果wordList扩展到整部字典，比如有40000个单词，那工作量不小了（考虑到每个方向上，可能的单词都会有多个；而且每次都要在40000个单词里查找）。此时再采用线性查找，就不靠谱了，所以考虑将wordList按字典顺序存储，采用二分查找，这样对于每个可能的单词最多16次比较就可以了。

进一步观察，假定某方向上检查到字符串qx，词典里没有以qx开头的单词，此时可以确定这个方向不需要进一步检查了。

剩下的问题是，怎样检查8个方向的单词呢？来看位于[0, 0]处的字符t（这里忽略掉所有的单字符单词，所以一个字符本身不会构成单词），向右检查，终点的位置分别是[0, 1]，[0, 2]，[0, 3]，即行索引不变，列索引递增；向右下方向检查，终点的位置分别是[1, 1]，[2, 2]，[3, 3]，即行索引、列索引同时递增。每个方向都是如此，这样我们找出每个方向上行索引、列索引的变化规律来，就容易实现了。

实现

现在通过上面分析到的二分查找、前缀检查和方向检查，基本上可以按思路直接写出来。创建类WordSearchPuzzle来完成功能，它的基本方法有：

在构造函数里，读取puzzle网格board和单词列表words，然后通过Solve方法进行检查，它会借助于SolveDirection和PrefixSearch方法。Solve的代码是：

public int Solve()
{
int matches = 0;
for (int rowIndex = 0; rowIndex < rows; rowIndex++)
{
for (int colIndex = 0; colIndex < columns; colIndex++)
{
for (int rd = -1; rd <= 1; rd++)
{
for (int cd = -1; cd <= 1; cd++)
{
if (rd!= 0 || cd != 0)
{
matches += SolveDirection(rowIndex, colIndex, rd, cd);
}
}
}
}
}

return matches;
}

这里通过rd和cd来表示行和列的变化方式，如当rd=0，cd=1，表示向右检查；当rd=-1，cd=-1，表示向左上方检查。rd和cd的取值都是-1、0、1，共有9中组合，除了(0, 0)，正好可以表示8个方向。

SolveDirection返回在指定位置的某个方向上找到了几个单词：

private int SolveDirection(int baseRow, int baseCol, int rowDelta, int colDelta)
{
string charSequence = theBoard[baseRow, baseCol].ToString();
int matches = 0;
int searchResult = 0;

for (int i = baseRow + rowDelta, j = baseCol + colDelta;
i >= 0 && j >= 0 && i < rows && j < columns;
i += rowDelta, j += colDelta)
{
charSequence += theBoard[i, j];
searchResult = PrefixSearch(words, charSequence);

if (searchResult < 0 || searchResult >= words.Length)
{
// No word with this prefix
break;
}

if (words[searchResult].Equals(charSequence))
{
matches++;
Console.WriteLine("Found '{0}' at [{1}, {2}] to [{3}, {4}]",
charSequence, baseRow, baseCol, i, j);
}
}

return matches;
}

通过for循环来检查这个方向上的所有单词，这里使用了前面提到的前缀检查，来避免不必要的查找。

对于PrefixSearch来说，虽然从名字来看，它查找的是前缀，但也包含了完全匹配的情况：

private static int PrefixSearch(string[] a, string x)
{
int index = Array.BinarySearch(a, x, new StringPrefixComparer());
return index;
}

这里调用了Array.BinarySearch方法，如果不提供一个comparer，它会使用默认的字符串比较，所以这里创建一个StringPrefixComparer：

internal class StringPrefixComparer : IComparer<string>
{
public int Compare(string x, string y)
{
if (x.StartsWith(y))
{
return 0;
}
else
{
return x.CompareTo(y);
}
}
}

如果以此为前缀的单词不存在，直接结束循环；如果以此为前缀的单词存在，就顺便检查下该前缀是否恰好匹配一个单词。至此，这个小puzzle就完成了。类的完整代码在这里。

单词列表文件里包含下面几个单词：

above
fat
flow
test
that
this
tweak
two
wcg
wow

可以这样调用Solve方法：

WordSearchPuzzle puzzle = new WordSearchPuzzle("puzzle.txt", "words.txt");
puzzle.Solve();

那么对于上面的网格，返回结果是：

Found 'this' at [0, 0] to [0, 3]
Found 'two' at [0, 0] to [2, 0]
Found 'fat' at [3, 0] to [1, 2]
Found 'that' at [3, 3] to [0, 0]

Array.BinarySearch方法

实际上，上面的StringPrefixComparer是可以省略的。直接使用Array.BinarySearch本身就够了。将SolveDirection和PrefixSearch改为：

private static int PrefixSearch(string[] a, string x)
{
int index = Array.BinarySearch(a, x);
return (index >= 0) ? index : ~index;
}

private int SolveDirection(int baseRow, int baseCol, int rowDelta, int colDelta)
{
string charSequence = board[baseRow, baseCol].ToString();
int matches = 0;
int searchResult = 0;

for (int i = baseRow + rowDelta, j = baseCol + colDelta;
i >= 0 && j >= 0 && i < rows && j < columns;
i += rowDelta, j += colDelta)
{
charSequence += board[i, j];
searchResult = PrefixSearch(words, charSequence);

// No words with this prefix.
if (searchResult == words.Length)
{
break;
}
if (!words[searchResult].StartsWith(charSequence))
{
break;
}

if (words[searchResult].Equals(charSequence))
{
matches++;
Console.WriteLine("Found '{0}' at [{1}, {2}] to [{3}, {4}]",
charSequence, baseRow, baseCol, i, j);
}
}

return matches;
}

也可以完成功能。原因是对于Array.BinarySearch方法来说，如果没有查找到，它不会直接返回-1。看上面的单词列表，如果查找this，会返回5，因为它刚好有匹配值；如果查找th，将返回-5，这个-5是列表中第一个大于th的项（that）的索引（4）的按位取补；如果查找的是wt，则返回-10，wt大于列表中所有项，-11即最后一项的索引（9）加一的按位取补。这样如果BinarySearch的结果是[0-9]，说明找到了匹配值；如果小于零，则按位取补返回，取补的结果为列表长度，说明该字符串大于每个单词，不可能有匹配，返回，否则检查该字符串是否为前缀。

以前没有注意到Array.BinarySearch的这个特性，原来它还有此用处:)

好了，现在可以放松一下，玩玩游戏了。

参考：

《数据结构与问题求解-Java语言描述（第3版）》

本文链接

整数的展开

2011-03-13T16:33:00Z

十进制计数

日常生活中整数最常见的表示形式为十进制。如965，它的值是9*10^2+6*10+5。从最开始接触数字，我们就在用十进制计数，可以确信对于任何一个非负整数n，都可以唯一地表示为如下的形式：

（公式1）

其中，k是非负整数，是小于10的非负整数（也即0到9）。可以将这个数字的表示简化为，这也正是我们所习惯的形式，一般把n称为（k+1）位数，如965是一个3位数。虽然根据经验可以得出，任何一个正整数n，都可以唯一地表示为上面的十进制形式，这里还是简单地证明一下（对下面的另外一种展开会有帮助）。

这里的证明需要分为两部分，一是存在性，二是唯一性。

存在性：对于来说，它所能表示的最大数为，如果可以证明它可以表示所有0到范围内的整数，就可以证明存在性了。这里采用归纳法：

基础步骤：k=0时，可以表示0-9（即0到）范围内的所有整数；

归纳步骤：假设对于整数m来说，命题成立，这样可以表示0到范围内的所有整数。考虑整数n，它满足，注意到，所以存在整数（），使得，也就是说可以表示所有0到范围内的整数。

这样，对于任意正整数n，总可以找到一个十进制数来表示，其中k=（[]为下取整函数）。

唯一性：可以用反证法证明，这里从略。

n的b进制展开

在计算机系统当中，使用更多的还是二进制、八进制和十六进制。上面十进制表示的结论也可以推广到任意的正整数b（b>1），也就是说，对于任意一个非负整数n，都可以唯一地表示为如下的形式：

（公式2）

这个形式可以称为n以b为基数（base）的展开，或者n的b进制展开，记为。当b=2时，也就是我们非常熟悉的二进制展开了，很多时候会遇到这方面的面试题：如何表示一个整数，二进制展开中有多少个1等等。那现在来考虑给定一个正整数n和基数b（b>1），如何求得n的b进制展开呢？通过公式2可以看到，迭代地使用带余除法，直到商为0即可。

private static readonly string digitTable = "0123456789abcdef";
private static readonly int maxBase = digitTable.Length;

/// <summary>
/// Base b expansion.
/// </summary>
/// <param name="n">n >= 0</param>
/// <param name="b">b in [2, 16]</param>
/// <returns></returns>
public static string Expansion(int n, int b)
{
Stack<string> remainders = new Stack<string>();
do
{
remainders.Push((n % b).ToString());
n /= b;
} while (n > 0);

return string.Join(string.Empty, remainders.ToArray());
}

如果n=165，b=8，则结果为245。

其它的展开形式

有趣的是，在对一个整数进行展开时，除了上面提到的b进制展开，还有其它形式的展开。比如康托尔（Cantor）展开，它是说对于任意一个非负整数n可以唯一地表示为如下的形式：

，其中为整数，且，i=1,2,...,n。

这个看起来有点儿不可思议。对于十进制展开来说，我们可以相信它可以连续地表示所有非负整数，而康托尔展开就没那么明显了。现在再次观察十进制展开，它为何能够连续地表示整数呢？一个k位数能够表示0到范围内的整数，而的下一个整数整数正好是一个（k+1）位数的最小值，这是关键之处。而它能够唯一地表示整数，在于如果i与j不相等，那么一个i位数和一个j位数就不可能相等，这样可以将所有整数按段来分隔了。

下面来考虑康托尔展开是否具有上段提到的两个性质。对于，可以记为，这样仍然可以用一位数、两位数来称呼它们。对于一位数，即k=1时，康托尔展开可以表示的数是0、1；对于两位数，即k=2时，康托尔展开可以表示的数是2、3、4、5；而三位数则可以表示6、7、...、23。看来至少在k不大于3时是可以连续、唯一地表示整数的。一般地，等式成立（可以用数学归纳法证明），而这一等式使得康托尔展开就跟上段提到的十进制展开的两个性质非常类似，这样就可以初步确定康托尔展开可以唯一地表示任意的非负整数了，详细的证明过程与十进制展开的证明类似，不再赘述。

参考：
《离散数学及其应用》
《数据结构与问题求解》

本文链接