最近面试阿里，第一个算法题就是字符串匹配算法，当时一脸懵逼，连朴素字符串匹配算法都不知道，面试官还问我有没有深入了解Python语言的字符串怎么查找的，顿时戳中痛点，想想自己学Python真的还是太浅了。于是就去把字符串匹配算法全学了一遍，有brute-force算法、Rabin-Karp算法、有限自动机算法、KMP算法、Boyer-Moore算法、Horspool算法还有Sunday算法等等。然后再去看了一下Python的字符串查找算法，链接地址为

https://github.com/python/cpython/blob/master/Objects/stringlib/fastsearch.h

该算法广泛用于find、index、 split、replace、 __contains__(in关键字的实现函数)等函数中。

在看下面之前，我假设读者知道什么是Horspool和Sunday算法了，我把这两个算法的Python实现贴出来，非常简单

1. #coding=utf-8
2. '''Horspool字符串匹配算法
3. 预处理时间复杂度时间为O(m)，最快时间复杂度为O(n/m)
4. 匹配时间快于Boyer-Moore算法
5. '''
7. def horspool_search(T, P):
8. n, m = len(T), len(P)
9. shift = [m for i in range( 256)]
10. for i in range(m -1):
11. shift[ord(P[i])] = m - i - 1
12. # 跟朴素算法的区别就在于步长
13. i = 0
14. while i < n-m+ 1:
15. for j in range(m):
16. if T[j+i] != P[j]:
17. break
18. else:
19. return i
21. i += shift[ord(T[i+m -1])]
22. return -1

1. #coding=utf-8
2. '''SUNDAY字符串匹配算法
3. 预处理时间复杂度时间为O(m)，最快时间复杂度为O(n/m)
4. 匹配时间快于Boyer-Moore算法
5. '''
7. def sunday_search(T, P):
8. n, m = len(T), len(P)
9. shift = [m+ 1 for i in range( 256)]
10. for i in range(m):
11. shift[ord(P[i])] = m - i
12. # 跟朴素算法的区别就在于步长
13. i = 0
14. while i < n-m+ 1:
15. for j in range(m):
16. if T[j+i] != P[j]:
17. break
18. else:
19. return i
20. if i+m < n:
21. i += shift[ord(T[i+m])]
22. else:
23. return -1

再来看Python的快速匹配算法，上面链接里的代码太多，因为考虑了多种情况，我们只看FASTSEARCH部分，抽取出来

1. #define STRINGLIB_BLOOM_WIDTH 32
3. /* 用于记录数组中存在的元素 */
4. #define STRINGLIB_BLOOM_ADD(mask, ch) \
5. ((mask |= (1UL << ((ch) & (STRINGLIB_BLOOM_WIDTH - 1)))))
6. /* 判断字符是否在数组中 */
7. #define STRINGLIB_BLOOM(mask, ch) \
8. ((mask & (1UL << ((ch) & (STRINGLIB_BLOOM_WIDTH - 1)))))
10. int fast_search(char *s, char *p) {
11. int n = strlen(s);
12. int m = strlen(p);
13. int w = n - m;
15. int mlast = m - 1;
16. int skip = mlast - 1;
17. int mask = 0;
19. int i, j;
20. const char *ss = s + m - 1;
21. const char *pp = p + m - 1;
23. /* create compressed boyer-moore delta 1 table */
25. /* process pattern[:-1] */
26. for (i = 0; i < mlast; i++) {
27. STRINGLIB_BLOOM_ADD(mask, p[i]);
28. if (p[i] == p[mlast])
29. skip = mlast - i - 1;
30. }
31. /* process pattern[-1] outside the loop */
32. STRINGLIB_BLOOM_ADD(mask, p[mlast]);
34. for (i = 0; i <= w; i++) {
35. /* note: using mlast in the skip path slows things down on x86 */
36. if (ss[i] == pp[ 0]) {
37. /* candidate match */
38. /* 因为已经判断字符串和模式串的最后一位相等 */
39. for (j = 0; j < mlast; j++)
40. if (s[i + j] != p[j])
41. break;
42. if (j == mlast) {
43. /* got a match! */
44. return i;
45. }
46. /* miss: check if next character is part of pattern */
47. if (!STRINGLIB_BLOOM(mask, ss[i + 1]))
48. i = i + m;
49. else
50. i = i + skip;
51. } else {
52. /* skip: check if next character is part of pattern */
53. if (!STRINGLIB_BLOOM(mask, ss[i + 1]))
54. i = i + m;
55. }
56. }
57. return -1;
58. }

BMHBNFS算法的原理可以用简单的代码来演示

1. def find(s, p):
2. # find first occurrence of p in s
3. n = len(s)
4. m = len(p)
5. # skip是把离p[m-1]最近且字符相同的字符移到m-1位需要跳过的步数-1
6. skip = delta1(p)[p[m -1]]
7. i = 0
8. while i <= n-m:
9. if s[i+m -1] == p[m -1]: # (boyer-moore)
10. # potential match
11. if s[i:i+m -1] == p[:m -1]:
12. return i
13. if s[i+m] not in p:
14. i = i + m + 1 # (sunday)
15. else:
16. i = i + skip # (horspool)
17. else:
18. # skip
19. if s[i+m] not in p:
20. i = i + m + 1 # (sunday)
21. else:
22. i = i + 1
23. return -1 # not found

作者当时在设计这个算法时考虑了如下几点限制条件：

1. 在任何测试用例下都要比brute-force算法快
2. 低预处理开销、不需要动态分配数组，也就是预处理时间复杂度为O(m)、空间复杂度为O(1)
3. 在较好的情况下，线性搜索时间复杂度为O(n/m)
4. 在最差的情况下也不会比现有算法的时间复杂度(O(nm))高
5. 在8bits、16bits字符串或者32bits Unicode字符串中表现良好
6. 在现实生活中的搜索中能够表现良好，很少出现最差情况
7. 实现简单