Python字符串查找算法之BMHBNFS算法

Posted Terry_dong

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python字符串查找算法之BMHBNFS算法相关的知识，希望对你有一定的参考价值。

最近面试阿里，第一个算法题就是字符串匹配算法，当时一脸懵逼，连朴素字符串匹配算法都不知道，面试官还问我有没有深入了解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;
  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;
  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;
  57. return -1;

这个快速匹配算法被称为BMHBNFS算法，之所以取这个名字，是因为它是Boyer-Moore, Horspool, Sunday, Bloom Filter几种算法的集大成者，我第一次看到这算法时感觉牛逼到爆，本来Horspool和Sunday已经算字符串匹配算法中的佼佼者了（最快时间复杂度为O(n/m)），居然还有这么一种算法。


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. 实现简单
有这么多限制，可想而知多牛逼，该算法的巧妙之处在于使用Bloom filter数据结构使得算法不再依赖字母表的大小， 空间复杂度降为O(1)，当然这样会导致处理起来比Horspool和Sunday算法复杂一点
参考资料：http://effbot.org/zone/stringlib.htm

以上是关于Python字符串查找算法之BMHBNFS算法的主要内容，如果未能解决你的问题，请参考以下文章

算法之--字符串包含python实现

从 python 中的随机输入字母中查找单词。已经有啥算法可以使用/编码？

KMP子串查找算法

华为OD机试 - 第 K 个最小码值的字母（Python） | 机试题+算法思路+考点+代码解析 2023

python算法之查找

常见查找算法之php, js,python版