字符串查找和匹配是一个很常用的功能，比如在爬虫，邮件过滤，文本检索和处理方面经常用到。相对与C，python在字符串的查找方面有很多内置的库可以供我们使用，省去了很多代码工作量。但是我们还是需要了解一些常用的字符串查找算法的实现原理。
首先来看python内置的查找方法。查找方法有find,index,rindex,rfind方法。这里只介绍下find方法。find方法返回的是子串出现的首位置。比如下面的这个，返回的是abc在str中的首位置也就是3。如果没找到将会返回-1
str = "dkjabcfkdfjkd198983abcdeefg"
print str.find(‘abc‘)
但是在str中有2个abc，那么如何去查找到第二个abc的位置呢。由于find是会返回查找到的字符串的首位置，因此我们可以利用这个位置继续往后搜索。代码如下
def str_search_internal():
str = "dkjabcfkdfjkd198983abcdeefg"
substr=‘abc‘
substr_len=len(substr)
start=0
while start <=len(str):
index=str.find(‘abc‘,start)
if index == -1:
return -1
else:
print index
begin=index+substr_len #每一次查找后就将开始查找的位置往后移动字串的长度
if begin <= len(str):
index=str.find(‘abc‘,begin)
print index
else:
return -1
start=index+substr_len
通过返回的index方式就可以不断的往下寻找后面匹配的字符串。
前面介绍了python内置的查找函数，那么如果我们不用这些内置的函数，自己如何编写查找函数呢。首先我们来看下朴素的串匹配应用。代码如下
def str_search():
str = "dkjabcfkdfjkd198983abcdeefg"
substr = ‘abc‘
substr_len = len(substr)
str_len=len(str)
i,j=0,0
while i < str_len and j < substr_len:
if str[i] == substr[j]: #如果匹配，则主串和子串的位置同时后移一位
i+=1
j+=1
else:#如果不匹配，主串移动到当前查找位置的后一位
i=i-j+1
j=0
if j == substr_len: #如果j到了子串的最后一位，表明已经找到匹配的
return i-j
return -1
从代码量的角度来看，直接使用find方法要省事得多。那么从代码的运行时间来看，谁更快呢。来比较下代码的运行时间
start=time.time()
str = "dkjabcfkdfjkd198983abcdeefg"
print str.find(‘abc‘)
end=time.time()
print ‘the time elapsed %f‘ % (end-start)
find方法使用的时间为0.000009
/usr/bin/python2.7 /home/zhf/py_prj/data_struct/chapter4.py
3
the time elapsed 0.000009
用朴素的匹配算法运行时间是0.000026,时间是find方法的3倍
start=time.time()
ret=str_search()
print ret
end=time.time()
print ‘the time elapsed %f‘ % (end-start)
/usr/bin/python2.7 /home/zhf/py_prj/data_struct/chapter4.py
3
the time elapsed 0.000026
我们考虑更极端的场景，将主串str初始化为
"dkjueireijkab139u8khbbzkjdfjdiuhfhhionknl90089122jjkdnbdfdfdfddfd981298989dhfjdbfjdbfjdbfjbj" \
"djkjdfkdjkfbkadfffffffffffffffffffffffffffffffffffjiiernkenknkdfndkfndkfbdhfkdfjkd198983abcdeefg"
长度更长且abc位于主串的偏后的位置。此时再来比较下两种方式的运行时间。
使用find方法的时间为0.000028
/usr/bin/python2.7 /home/zhf/py_prj/data_struct/chapter4.py
180
the time elapsed 0.000028
使用朴素查找方式的时间为0.000222. 时间增长了将近10倍。因为可以看到字符串的规模越大，使用find方法的时间越少，查找速度越快。
/usr/bin/python2.7 /home/zhf/py_prj/data_struct/chapter4.py
180
the time elapsed 0.000222
通过对比可以发现朴素查找算法的效率很低，原因在于执行的过程在不断的回溯，匹配中遇到字符不同的时候，主串str将右移一个字符位置，随后的匹配回到子串substr的开始继续开始匹配。这种方式完全没有利用之前查找得到的信息来进行下一步的判断，可以认为是一种暴力搜索。假设有如下的场景主串是000000000000000000001。子串是001。而001位于最后3位。按照朴素查找方法，这个算法的复杂性为O(m*n).
由于朴素查找算法的效率太低，因此来看下一种查找效率更高的算法：KMP算法。
比如abc这个串找它在abababbcabcac这个串中第一次出现的位置，那么如果直接暴力双重循环的话，abc的c不匹配主串中的第三个字母a后，abc将开始从母串中的头位置的下一个位置开始寻找，就是abc开始匹配主串中第二个字母bab...这样。但是其实在主串中能够匹配的字母应该是a开始的，因此abc去匹配bab一开始也是不匹配的。这样多出了一次无谓的匹配。效率更高的方法就是用abc去匹配主串中的第三个字母aba
而KMP的优势就在于可以让模式串向右滑动尽可能多的距离就是abc直接从模式串的第三个字母aba...开始匹配，为了实现这一目标，KMP需要预处理出模式串的移位跳转next数组。
我们来用一个实际的例子来看下该如何优化
1 下面的例子在子串和主串比较到D的时候发现不一致了
按照朴素的搜索算法，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍
当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。如下图，因为有相同的AB存在，因此直接移动AB的位置进行比较
下面来介绍kmp算法的思想。
在字符串S中寻找M，假设匹配到位置i时两个字符才出现不相等(i位置前的字符都相等)，这时我们需要将字符串M向右移动。常规方法是每次向右移动一位，但是它没有考虑前i-1位已经比较过这个事实，所以效率不高。事实上，如果我们提前计算某些信息，就有可能一次右移多位。假设我们根据已经获得的信息知道可以右移x位，我们分析移位前后的M的特点，可以得到如下的结论：
B段字符串是M的一个前缀
A段字符串是M的一个后缀
A段字符串和B段字符串相等
所以右移x位之后，使M[k] 与 S[i] 对齐，继续从i位置进行比较的前提是：M的前缀B和后缀A相同。
这样就可以得出KMP算法的核心思想：
KMP算法的核心即是计算字符串M每一个位置之前的字符串的前缀和后缀公共部分的最大长度。获得M每一个位置的最大公共长度之后，就可以利用该最大公共长度快速和字符串S比较。当每次比较到两个字符串的字符不同时，我们就可以根据最大公共长度将字符串M向右移动，接着继续比较下一个位置。
所以KMP就需要找出前缀和后缀的最大长度并记录下来，也就是我们用到的next数组。
这里需要对前缀和后缀的意义进行解释下
"前缀"指除了最后一个字符以外，一个字符串的全部头部组合；"后缀"指除了第一个字符以外，一个字符串的全部尾部组合。举个例子来说明下，比如字符串ABCDABD
－ "A"的前缀和后缀都为空集，共有元素的长度为0；
－ "AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；
－ "ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；
－ "ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；
－ "ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；
－ "ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；
－ "ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0
对于目标字符串ptr，ababaca，长度是7，所以next[0]，next[1]，next[2]，next[3]，next[4]，next[5]，next[6]分别计算的是
a，ab，aba，abab，ababa，ababac，ababaca的相同的最长前缀和最长后缀的长度.所以next数组的值是[-1,-1,0,1,2,-1,0]，这里-1表示不存在，0表示存在长度为0，2表示存在长度为2
为方便起见，next数组下标都从1开始，M数组下标依然从0开始
假设我们现在已经求得next[1]、next[2]、……next[i]，分别表示不同长度子串的前缀和后缀最大公共长度，下面介绍如何用归纳法计算next[i+1] ?
假设k＝next[i]，它表示M位置i之前的字符串的前缀和后缀最大公共长度，即M[0...k-1] = M[i-k...i-1]；
比如假设子串为如下。
a b c e r e j k a b c k
0 1 2 3 4 5 6 7 8 9 10 11
那么next[11]=3。M[0-2]=M[11-3..11-1]=M[8,10]。这个就表示位置11之前的字符串的前缀和后缀的最大公共长度为3
接下来看下如何求出next数组. k表示前缀数据，i表示后缀数据
(1)若M[k] ＝ M[i]相等, 则必定有next[i+1] ＝ next[i] ＋1，即M位置i＋1之前的字符串的前缀和后缀最大公共长度为k+1。还是按照上面的字符串为例M[2]=M[10], next[11]=3,next[10]=2, 因此next[i+1]=next[i]+1
(2)若M[k] !＝ M[i], 则 k索引next[k]直到与p[j]相等或者前缀子符串长度为0，此时可用公式next[j+1]=k+1
归纳一下：令 next[k] = j, 继续判断M[i] 与 M[j] 是否相等，如果相等则 next[i+1] ＝ next[k] ＋ 1 ＝ next[ next[i] ] ＋ 1；如果不相等重复步骤(2)，继续分割长度为next[ next[k] ]的字符串，直到字符串长度为0为止
那么为了实现这种生成关系，我们需要设定一个标量，设定k的前缀初始值为-1。next数组全部也初始为-1。我们还是以这个字符串为例.j=0
a b c e r e j k a b c k
0 1 2 3 4 5 6 7 8 9 10 11
1 next[0]：从第一个字母开始，没有可对比前缀和后缀，因此等于-1.这里我们用-1这个标量也是为了表示没有找到匹配的前缀和后缀. j=0 k=-1
2 next[1]: 求ab的最大公共长度，由于k=-1，没有可匹配的前缀。因此next[1]=0, j=1,k=0
3 next[2]: 求abc的最大公共长度，此时P[1]!=P[0], 继续向前最小子串查找k=next[k=0]=-1没有找到可匹配的前缀，因此next[2]=0 j=2,k=0
4 next[3]: 求abce的最大公共长度。由于p[2]!=p[0], 因此继续往前缀查找。也就是k=next[k]=next[0]=-1. 由于k=-1没有找到可匹配的前缀,因此next[3]=0. 变量j=3,k=0
.
.
.
.
.
5 next[9],求abcerejkab的最大公共长度. p[8]=p[0]。因此next[9]=next[8]+1=0+1=1 j=9,k=1
6 next[10],求abcerejkabc的最大公共长度. p[9]=p[1]。因此next[10]=next[9]+1=1+1=2 变量:j=10,k=2
7 next[11],求abcerejkabck的最大公共长度. p[10]=p[2]。因此next[10]=next[9]+1=2+1=3 变量:j=11,k=3
根据前面的描述就可以得出我们的代码实现
def get_next(substring):
lenth=len(substring)
next_table=[-1]*lenth
k=-1
j=0
while j < lenth-1:
#substring[j]表示后缀，substring[k]表示前缀
if k==-1 or substring[j]==substring[k]:
j+=1
k+=1
next_table[j]=k
print j,k,next_table
#没有找到匹配的，继续往前最小子串进行查找
else:
k=next_table[k]
return next_table
因此可以得到next表如下：
[-1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3]
既然next表已经得到，我们就可以写出对应的KMP算法实现了
def kmp_function(str,substring):
len1=len(str)
len2=len(substring)
next_table=get_next(substring)
print next_table
k=-1
i=0
while i < len1:
while(k>-1 and substring[k+1] != str[i]):
k=next_table[k]
if substring[k+1] == str[i]:
k=k+1
if k==len2-1:
return i-len2+1
i+=1
从这个实现可以看出KMP的实现复杂度为O(m+n),比朴素的查找算法的O(m*n)提高了不少.那么我们继续分析下ＫＭＰ算法是否有优化的空间呢. 来看下面的例子：
如果用之前的next 数组方法求模式串“abab”的next 数组，可得其next 数组为-1 0 0 1（0 0 1 2整体右移一位，初值赋为-1），当它跟下图中的文本串去匹配的时候，发现b跟c失配，于是模式串右移j - next[j] = 3 - 1 =2位。
右移2位后，b又跟c失配。事实上，因为在上一步的匹配中，已经得知p[3] = b，与s[3] = c失配，而右移两位之后，让p[ next[3] ] = p[1] = b 再跟s[3]匹配时，必然失配。问题出在哪呢？
问题出在不该出现p[j] = p[ next[j] ]。为什么呢？理由是：当p[j] != s[i] 时，下次匹配必然是p[ next [j]] 跟s[i]匹配，如果p[j] = p[ next[j] ]，必然导致后一步匹配失败（因为p[j]已经跟s[i]失配，然后你还用跟p[j]等同的值p[next[j]]去跟s[i]匹配，很显然，必然失配），所以不能允许p[j] = p[ next[j] ]。如果出现了p[j] = p[ next[j] ]咋办呢？如果出现了，则需要再次递归，即令next[j] = next[ next[j] ]。总结即是：
如果a位字符与它的next值(即next[a])指向的b位字符相等（即p[a] == p[next[a]]）,则a位的next值就指向b位的next值即（next[ next[a] ]）。
那么代码修改如下就可以了：
def get_next(substring):
lenth=len(substring)
next_table=[-1]*lenth
k=-1
j=0
while j < lenth-1:
if k==-1 or substring[j]==substring[k]:
j+=1
k+=1
＃如果p[j]==p[next[j]],则继续递归，直到p[j]!=p[next[j]]
if substring[j] == substring[k]:
next_table[j]=next_table[k]
else:
next_table=k
else:
k=next_table[k]
return next_table
