字符串回溯匹配(朴素算法)
算法基本思想:
将搜索词整个后移一位,再从头逐个比较。这样做虽然可行,但是效率很差,因为你要把”搜索位置”移到已经比较过的位置,重比一遍。
'''
Creat by HuangDandan
2018-08-19
dandanhuang@sjtu.edu.cn
字符串匹配朴素算法
算法基本思想:
将搜索词整个后移一位,再从头逐个比较。这样做虽然可行,但是效率很差,因为你要把"搜索位置"移到已经比较过的位置,重比一遍
遇字符不等时将模式串p右移一个字符,再次从p0(重置j = 0 后)开始比较
最坏情况是每趟比较都在最后出现不等,最多比较n-m+1 趟,总比较次数为m*(n-m+1),所以算法时间复杂性为O(m*n)
'''
def nmatching(t, p):
i, j = 0, 0
n, m = len(t), len(p)
while i < n and j < m:
if t[i] == p[j]:
i, j = i+1, j+1
else:
i, j = i-j+1, 0 #i-j+1是关键,遇字符不等时将模式串t右移一个字符
if j == m: #找到一个匹配,返回索引值
return i-j
return -1 #未找到,返回-1
# else:
# return -1
t = 'aabaabaabab'
p = 'baab'
print(nmatching(t,p))
KMP算法
基本思想:
当字符不匹配时,你其实知道前面的字符是什么。KMP算法的想法是设法利用这个已知信息,不要把字符串t中的”搜索位置”移回已经比较过的位置,继续把搜索位置向后移。匹配中只做不得不做的字符比较,字符串t搜索位置i不回溯。可以针对搜索词,算出一张《部分匹配表》(Partial Match Table)
KMP算法流程:
假设当前字符串t匹配到 i 位置,模式串P匹配到 j 位置.
- if j = -1,或者当前字符匹配成功(即t[i] == p[j]),则i,j= i+1, j+1,继续匹配下一个字符;
if j != -1,且当前字符匹配失败(即t[i] != p[j]),则 i 不变,j = next[j]。此举意味着失配时,模式串P相对于字符串S向右移动了j - next [j] 位。
- 上面两个if判断在字符串没有搜索结束前,两个条件必定满足一个,两个条件互为否命题。
- 当匹配失败时,模式串向右移动的位数为:失配字符所在位置 - 失配字符对应的next 值,即移动的实际位数为:j - next[j],且此值大于等于1。
pnext 数组各值含义
- pnext 数组各值含义:代表当前字符之前的字符串中,有多大长度的相同前缀后缀。例如next [j] = k,代表j 之前的字符串中有最大长度为k 的相同前缀后缀。(p0p1……pk-1 = pj-kpj-k+1……pj-1)。即:模式串向右移动的位数为:已匹配字符数 - 失配字符的上一位字符所对应的最大长度值
- 某个字符失配时,该字符对应的next 值会告诉你下一步匹配中,模式串应该跳到哪个位置(跳到next [j] 的位置)。
- 如果next [j] 等于0或-1,则跳到模式串的开头字符,若next [j] = k 且 k > 0,代表下次匹配跳到j 之前的某个字符,而不是跳到开头,且具体跳过了k 个字符。
- 具体解释:某个字符失配时,j = next [j],模式串向右移动的位数为:j - next[j]。换言之,当模式串的后缀pj-k pj-k+1, …, pj-1 跟文本串ti-k ti-k+1, …, ti-1匹配成功,但pj 跟ti匹配失败时,因为next[j] = k,相当于在不包含pj的模式串中有最大长度为k 的相同前缀后缀,即p0 p1 …pk-1 = pj-k pj-k+1…pj-1,故令j = next[j],从而让模式串右移j - next[j] 位,使得模式串的前缀p0 p1, …, pk-1对应着文本串 si-k si-k+1, …, si-1,而后让pk 跟ti 继续匹配。
模式串p中长度最大且相等的前缀和后缀
对于P = p0 p1 …pj-1 pj,寻找模式串p中长度最大且相等的前缀和后缀。如果存在p0 p1 …pk-1 = pj- kpj-k+1…pj-2 pj-1,那么在包含pj-1的模式串中有最大长度为k的相同前缀后缀。以”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;k=1
- ”ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA],后缀为[BCDAB, CDAB, DAB, AB, B],共有元素为”AB”,长度为2;k=k+1=2
- ”ABCDABD”的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB],后缀为[BCDABD, CDABD, DABD, ABD, BD, D],共有元素的长度为0。
结合之前的《最大长度表》和上述结论,进行字符串的匹配。如果给定文本串“BBC ABCDAB ABCDABCDABDE”,和模式串“ABCDABD”,现在要拿模式串去跟文本串匹配,如下图所示:
- 因为模式串中的字符A跟文本串中的字符B、B、C、空格一开始就不匹配,已经匹配的字符串长度=0,最长长度表为0,next [j] 等于0或-1,模式串p的搜索位置一直停在开头字符处,只需要直接将字符串t的搜索位置i不断的后移移一位即可,直到模式串中的字符A跟文本串的第5个字符A匹配成功
- 继续往后匹配,当模式串最后一个字符D跟文本串匹配时失配,显而易见,模式串需要向右移动。但向右移动多少位呢?因为此时已经匹配的字符数为6个(ABCDAB),然后根据《最大长度表》可得失配字符D的上一位字符B对应的长度值为2,所以根据之前的结论,可知需要向右移动6 - 2 = 4 位。
- 模式串向右移动4位后,发现C处再度失配,因为此时已经匹配了2个字符(AB),且上一位字符B对应的最大长度值为0,所以向右移动:2 - 0 =2 位。
- 继续比较,发现D与C 失配,故向右移动的位数为:已匹配的字符数6减去上一位字符B对应的最大长度2,即向右移动6 - 2 = 4 位。
- 继续比较,发现匹配成功,过程结束。
next 数组相当于“最大长度值” 整体向右移动一位,然后初始值赋为-1。
根据《最大长度表》,失配时,模式串向右移动的位数 = 已经匹配的字符数 - 失配字符的上一位字符的最大长度值。而根据《next 数组》,失配时,模式串向右移动的位数 = 失配字符的位置 - 失配字符对应的next 值。其中,从0开始计数时,失配字符的位置 = 已经匹配的字符数(失配字符不计数),而失配字符对应的next 值 = 失配字符的上一位字符的最大长度值,两相比较,结果必然完全一致。
关键:计算pnext表:
递推算法流程:
利用已知pnext[0]= -1 直至pnext[i] 求pnext[i+1] 的算法:
1. 假设pnext [j] = k。
2. 若pk = pj,字符串匹配,则p0… pj-k…pj的最大相同前后缀的长度就是k+1,记入pnext[j+1], j +1后继续递推(循环),则pnext[j + 1 ] = pnext [j] + 1 = k + 1
3. 若pk ≠ pj,字符串不匹配,则去寻找长度更短一点的相同前缀后缀。如果此时p[ pnext[k] ] == p[j ],则pnext[ j + 1 ] = pnext[k] + 1,否则继续递归前缀索引k = pnext[k],而后重复此过程。 相当于在字符p[j+1]之前不存在长度为k+1的前缀”p0 p1, …, pk-1 pk”跟后缀“pj-k pj-k+1, …, pj-1 pj”相等,那么是否可能存在另一个值t+1 < k+1,使得长度更小的前缀 “p0 p1, …, pt-1 pt” 等于长度更小的后缀 “pj-t pj-t+1, …, pj-1 pj” 呢?如果存在,那么这个t+1 便是pnext[ j+1]的值,此相当于利用已经求得的next 数组(pnext [0, …, k, …, j])进行P串前缀跟P串后缀的匹配。
5. 若k 值为-1(一定来自pnext),得到p0… pi-k…pi 中最大相同前后缀的长度为0,设pnext [i+1] = 0,将i 值加一后继续递推
关于第三步的递归进一步理解:
- 字符串不匹配,则去寻找长度更短一点的相同前缀后缀。若能在前缀“ p0 pk-1 pk ” 中不断的递归前缀索引k = pnext
[k],找到一个字符pk’ 也为D,代表pk’ = pj,且满足p0 pk’-1 pk’ = pj-k’ pj-1
pj,则最大相同的前缀后缀长度为k’ + 1,从而next [j + 1] = k’ + 1 = pnext [k’ ] +
1。否则前缀中没有D,则代表没有相同的前缀后缀,pnext [j + 1] = 0。 - 不断递推的过程:开始 j=pnext[j]=k ,也就是说后面将k看作 j ,继续递推,k= pnext[k]。
@python程序程序
'''
Creat by HuangDandan
2018-08-21
dandanhuang@sjtu.edu.cn
字符串匹配KMP算法
思想:
关键:
1-整个KMP的重点就在于当某一个字符与主串不匹配时,我们应该知道j指针要移动到哪?
当匹配失败时,j要移动的下一个位置k。存在着这样的性质:最前面的k个字符和j之前的最后k个字符是一样的。 p[0~k-1] == p[j-k,j-1]
2-怎么求这个(这些)k呢?
根据模式串p 做出pnext 表,即根据j递推计算最长相等前后缀的长度
因为在P的每一个位置都可能发生不匹配,也就是说我们要计算每一个位置j对应的k,
所以用一个列表next来保存,当T[i] != P[j]时,j指针的下一个位置pnext[j]
求pnext 的问题变成对每个i 求p 的(前缀)子串p0…pi-1 的最长相等前后缀的长度。
KMP 提出了一种巧妙的递推算法:
1. 假设pnext [j] = k。
2. 若pk = pj,字符串匹配,则p0… pj-k…pj的最大相同前后缀的长度就是k+1,记入pnext[j+1], j +1后继续递推(循环),则pnext[j + 1 ] = pnext [j] + 1 = k + 1
3. 若pk ≠ pj,字符串不匹配,则去寻找长度更短一点的相同前缀后缀。如果此时p[ pnext[k] ] == p[j ],则pnext[ j + 1 ] = pnext[k] + 1,否则继续递归前缀索引k = pnext[k],而后重复此过程。 相当于在字符p[j+1]之前不存在长度为k+1的前缀"p0 p1, …, pk-1 pk"跟后缀“pj-k pj-k+1, …, pj-1 pj"相等,那么是否可能存在另一个值t+1 < k+1,使得**长度更小的前缀** “p0 p1, …, pt-1 pt” 等于长度更小的后缀 “pj-t pj-t+1, …, pj-1 pj” 呢?如果存在,那么这个t+1 便是pnext[ j+1]的值,此相当于利用已经求得的next 数组(pnext [0, ..., k, ..., j])进行P串前缀跟P串后缀的匹配。
5. 若k 值为-1(一定来自pnext),得到p0… pi-k…pi 中最大相同前后缀的长度为0,设pnext [i+1] = 0,将i 值加一后继续递推
时间复杂度:
算法复杂性的关键是循环。注意循环中i 的值递增,但加一的总次数不多于n = len(t)。而且i 递增时j值也递增。另一方面j = pnext[j] 总使j 值减小,但条件保证其值不小于–1,因此j = pnext[j] 的执行次数不会多于j 值递增的次数。循环次数是O(n),算法复杂性也是O(n)
'''
def matchingKMP(t,p,pnext): #需要传入一个部分匹配表pnext
i, j = 0, 0
n, m = len(t), len(p)
while i < n and j < m:
if j == -1 or t[i] == p[j]: #如果j = -1,或者当前字符匹配成功(即S[i] == P[j]),都令i+1,j+1
i, j = i+1, j+1
else: #如果j != -1,且当前字符匹配失败(即S[i] != P[j]),则令 i 不变,j = next[j] # next[j]即为j所对应的next值
j = pnext[j]
if j == m: # 找到匹配,返回索引值
return i - j
return -1 # 无法匹配,返回-1
def genPNext0(p):
j, k, m = 0, -1, len(p)
pnext = [-1]*m
while j < m-1: #生成pnext
while k >= 0 and p[j] != p[k]:
k = pnext[k]
j, k = j+1, k+1
pnext[j] = k #考虑前面
return pnext
#生成pnext表,作用:当模式串中的某个字符跟文本串中的某个字符匹配失配时,模式串下一步应该跳到哪个位置
def genPNext(p):
j, k, m = 0, -1, len(p)
pnext = [-1]*m
while j < m-1: #生成pnext
while k >= 0 and p[j] != p[k]:
k = pnext[k] #设k = pnext[k]
j, k = j+1, k+1
if p[j] == p[k]: #递推过程
pnext[j] = pnext[k]
else:
pnext[j] = k #next [j] = k 且 k > 0,表示下次匹配跳到j 之前的某个字符,而不是跳到开头,且具体跳过了k 个字符
return pnext
if __name__ == "__main__":
t = 'bbc abcdab abcdabdabde'
p = 'abcdabdab'
print('------------------------------------')
print(matchingKMP(t,p,genPNext(p)))
参考博客:
https://www.cnblogs.com/zhangtianq/p/5839909.html
https://www.cnblogs.com/yjiyjige/p/3263858.html