Programming Pearls笔记之三
Programming Pearls笔记之三
这里是编程珠玑（Programming Pearls）第三部分（后五个专栏）的笔记．
1 Partition
快速排序最关键的一步是Ｐａｒｔｉｔｉｏｎ，将一个元素放在正确的位置，它前面的元素都小于它，它后面的元素都不小于它．
1.1 Ｎｉｃｏ Ｌｏｍｕｔｏ的方法
对于一个值ｔ，将数组分成两部分，一部分小于ｔ，一部分大于等于ｔ．如图：
图一
相应算法为：
m = a-1 for i = [a, b] if x[i] < t swap(++m, i)
将ｘ［ｌ］作为数值ｔ，如下图：
图二
这时的ａ即ｌ＋１．ｂ即ｕ．算法终结时的状态是：
图三
最后还要交换ｘ［ｌ］和ｘ［ｍ］，状态为：
图四
1.2 一些改进
Ｌｏｍｕｔｏ的方法有一点问题，就是当重复元素较多时效率会较差．对于ｎ个元素全部相同的极端情况，时间复杂度变为Ｏ（ｎ）．下面的方案会较好：
图五
这时算法是：
t = x[l]; i = l; j = u+1
loop
do i++ while i <=u && x[i] < t
do j-- while x[j] > t
if i > j
break
swap(i, j)
swap(l, j)
当所有元素都相等时．这个算法会交换相等的元素，这是不必要的．但它会将数组从正中间分成两部分，所以时间复杂度是Ｏ（ｎ ｌｏｇ ｎ）．这也是严、吴版《数据结构》课本上给出的算法．
另外为了取得较好的平均时间复杂度，可以引用随机数：ｓｗａｐ（ｌ，ｒａｎｄｉｎｔ（ｌ，ｕ））．即随机将数组中的一个元素跟ｘ［ｌ］，用它作为ｔ．
还有就是当ｕ－ｌ较小时，快速排序效率并不好，这时可以设置一个临界值，当ｕ－ｌ小于这个值时不再进行Ｐａｒｔｉｔｉｏｎ操作而是直接返回，这样最终结果虽然不是有序的，但却是大致有序的，这时可以再用插入排序处理一遍．
2 Ｒ．Ｓｅｄｇｅｗｉｃｋ的优化
- 问题
通过让ｘ［ｌ］作为哨兵元素，去掉Ｌｏｍｕｔｏ的算法中循环后面的那个ｓｗａｐ语句．
可以说这个改进没什么用处，因为只是少了一个交换语句，但这个问题很有意思．
- 解答
Ｂｏｂ Ｓｅｄｇｅｗｉｃｋ发现可以修改Ｌｍｕｔｏ的方案，从右往左处理数组元素，这样ｘ［ｌ］就可以作为一个哨兵元素，数组状态如下：
图六
算法伪代码是：
m = u+1 for (i = u; i >= l; i--) if x[i] >= t swap(--m, i)
当算法处理完后ｘ［ｍ］＝ｔ，因此也就不用再交换了．利用这个方案Ｓｅｄｇｅｗｉｃｋ还可以省掉循环中的一个判断语句：
m = i = u+1 do while x[--i] < t ; swap(--m, i) while i != l
3 第ｋ小元素
- 问题
查找数组ｘ［０．．ｎ－１］中第ｋ小元素，要求时间复杂度为Ｏ（ｎ），允许改变数组中元素顺序．
- 解答
这个很简单，只是对Ｐａｒｔｉｔｉｏｎ稍作修改．Ｃ．Ａ．Ｒ．Ｈｏａｒｅ的算法：
void select1(l, u, k) pre l <= k <= u post x[l..k-1] <= x[k] <= x[k+1..u] if l >= u return swap(l, randint(l, u)) t = x[l]; i = l; j = u+1 loop do i++; while i <= u && x[i] < t do j--; while x[j] >t if i > j break temp = x[i]; x[i] = x[j]; x[j] = temp swap(l, j) if j < k select1(j+1, u, k) else if j > k select1(l, j-1, k)
4 抽样问题
从０．．ｎ－１中等概率随机选取ｍ（ｍ＜ｎ）个并升序输出，要求不能有重复数值．
4.1 Ｋｎｕｔｈ的方法Ｓ
select = m remaining = n for i = [0, n) if (bigrand() % remaining) < select print i select-- remaining--
其中的ｂｉｇｒａｎｄ（）是产生一个随机整数．
巧妙之处是直接升序考查，输出，不用再排序了．
4.2 Ｋｎｕｔｈ的方法Ｐ
先将数组随机打乱，然后将前ｍ个排序．
for i = [0, n) swap(i, randint(i, n-1)) sort(x, x+m) for i = [0, m) printf x[i]
Ａｓｈｌｅｙ Ｓｈｅｐｈｅｒｄ和Ａｌｅｘ Ｗｏｒｏｎｏｗ发现只要对前ｍ个进行打乱操作就行了：
void genshuf(int m, int n) { int i, j; int *x = new int[n]; for (i = 0; i < n; i++) x[i] = i; for (i = 0; i < m; i++) { j = randint(i, n-1); int t = x[i]; x[i] = x[j]; x[j] = t; } sort(x, x+m); for (i = 0; i < m; i++) cout << x[i] <<"\n"; }
4.3 ｍ接近ｎ的情况
- 问题
当ｍ接近ｎ时，容易想到的解法是找出要舍弃的ｎ－ｍ个，然后剩下的就是要选取的．然而此处的问题是：
当ｍ接近ｎ的时候，基于集合的方法会产生很多重复的随机数值．要求设计一种算法，即使在最坏的情况下也只需要产生ｍ个随机数．
问题中基于集合的算法如下：
initialize set S to empty size = 0 while size < m do t = bigrand() % n if t is not in S insert t into S size++ print the elements of S in sorted orrder
- 解答
下面是Ｂｏｂ Ｆｌｏｙｄ的算法：
void genfloyd(int m, int n) { set<int S; set<int>::iterator i; for (int j = n-m; j < n; j++) { int t = bigrand() % (j+1); if (S.find(t) == S.end()) S.insert(t); // t not in S else S.insert(j); // t in S } for (i = S.begin(); i != S.end(); ++i) cout << *i <<"\n"; }
4.4 ｎ未知时的情况
- 问题
读取一篇文章，等概率地随机输出其中的一行．
这里ｎ在读完文章之前未知，ｍ＝１．
- 解答
可以先选中第一行，当读入第二行时，再以１／２的概率选中第二行，读入第三行时再以１／３的概率选中第三行．．．最后输出选中行．
i = 0 while more input lines with probability 1.0/++i choice = this input line print choice这个算法可以用数学归纳法作下不太正式的证明：选中每一行的概率都是１／ｎ．
- 当ｎ＝１时，以１００％的概率选中第一行，满足要求．
- 假设当ｎ＝ｋ时，满足要求．则当输入第ｋ＋１行时，选中第ｋ＋１行的概率为１／（ｋ＋１）．这一事件对于前ｋ行的影响是相同的，又因为原来（读入第ｋ＋１行之前）选中前ｋ行中任一行的概率是相同的，所以读入第ｋ＋１行之后选中前ｋ行中任一行的概率也是相同的．这时选中前ｋ行的概率是１－１／（ｋ＋１）．故选中前ｋ行任一行的概率也是１／（ｋ＋１）．所以当ｎ＝ｋ＋１时，也符合要求．
- 综上，算法满足要求．
- 笔记
上面的问题是ｍ＝１时的情况，当ｍ＞１时，可以先确定前ｍ行为已经选中，然后对于后面的第ｉ行（ｍ＜ｉ＜ｎ）以ｍ／ｉ的概率选中它，并随机替换掉已经选中的ｍ行中的一行，这时要产生两个随机数，一个用来确定是否选中该行，一个用来确定换掉ｍ行中的哪一行，可以将这两步操作合并成一步，只用求一个随机数，算法如下：1
i = 0 while more input lines if i < m x[i++] = this input line else t = bigrand() % (++i) if t < m x[t] = this input line for i = [0, m) printf x[i]
算法中的行数ｉ是从０开始的，这样利用ｂｉｇｒａｎｄ（）求出的ｔ，就不用再加１了．根据上面的算法也可以得出ｍ接近ｎ的情况的另外一个较好的解，因此ｍ比较接近ｎ，因此ｎ－ｍ较小，此时只用产生比较少的ｎ－ｍ个随机数即可：
for i = [0, m) x[i] = i for i = [m, n) t = bigrand() % (i+1) if (t < m) x[t] = i for i = [0, m) print x[i]
5 最长重复子串
- 问题
求出在一个字符串中重复出现的子串，比如对于字符串＂ｂａｎａｎａ＂，字符串＂ａｎａ＂是最长重复子串，因为出现了两次：ｂ ａｎａ ｎａ和ｂａｎ ａｎａ ．
- 解答
仍以字符串＂ｂａｎａｎａ＂为例．可以先建一个指针数组ａ，ａ［０］指向整个字符串，ａ［１］指向以ａ开头的后缀，ａ［２］指向以ｎ开头的后缀：
- ａ［０］： ｂａｎａｎａ
- ａ［１］： ａｎａｎａ
- ａ［２］： ｎａｎａ
- ａ［３］： ａｎａ
- ａ［４］： ｎａ
- ａ［５］： ａ
然后对这个指针数组调用ｑｓｏｒｔ（）进行排序就行了．比较函数是对元素指向的字符串的大小进行比较．在本例中，结果为：
- ａ［０］： ａ
- ａ［１］： ａｎａ
- ａ［２］： ａｎａｎａ
- ａ［３］： ｂａｎａｎａ
- ａ［４］： ｎａ
- ａ［５］： ｎａｎａ
最后只要比较排序后相信的子串，就可以得出最长重复子串，即＂ａｂａ＂．