KMP算法中，求prefix table时若P[k]！=P[i+1]的操作如何理解。

你的位置：网站首页 >> 频道首页 >>算法 >>KMP算法中，求prefix table时若P[k]！=P[i+1]的操作如何理解。

KMP算法中，求prefix table时若P[k]！=P[i+1]的操作如何理解。

来源：蜘蛛抓取(WebSpider) 时间：2019-01-28 17:23 标签： P/A

KMP算法看懂了觉得特别简单思路很简单，看不懂之前查各种资料，看的稀里糊涂即使网上最简单的解释，依然看的稀里糊涂
我花了半天时间，争取用最短的篇幅大致搞明白这玩意到底是啥
这里不扯概念，只讲算法过程和代码理解：

KMP算法求解什么类型问题

字符串匹配给伱两个字符串，寻找其中一个字符串是否包含另一个字符串如果包含，返回包含的起始位置

问题类型很简单，下面直接介绍算法

一般匹配字符串时我们从目标字符串str（假设长度为n）的第一个下标选取和ptr长度（长度为m）一样的子字符串进行比较，如果一样就返回开始处的下标值，不一样选取str下一个下标，同样选取长度为n的字符串进行比较直到str的末尾（实际比较时，下标移动到n-m）这样的時间复杂度是O(n*m)。

KMP算法：可以实现复杂度为O(m+n)

为何简化了时间复杂度：
充分利用了目标字符串ptr的性质（比如里面部分字符串的重复性即使不存在重复字段，在比较时实现最大的移动量）。
上面理不理解无所谓我说的其实也没有深刻剖析里面的内部原因。

考察目标字符串ptr：
這里我们要计算一个长度为m的转移函数next

next数组的含义就是一个固定字符串的最长前缀和最长后缀相同的长度。

比如：abcjkdabc那么这个数组的最長前缀和最长后缀相同必然是abc。
cbcbc最长前缀和最长后缀相同是cbc。
abcbc最长前缀和最长后缀相同是不存在的。

**注意最长前缀：是说以第一个字苻开始但是不包含最后一个字符。
比如aaaa相同的最长前缀和最长后缀是aaa**
a，ababa，ababababa，ababacababaca的相同的最长前缀和最长后缀的长度。由于aab，abaabab，ababaababac，ababaca的相同的最长前缀和最长后缀是“”“”，“a”“ab”，“aba”“”，“a”,所以next数组的值是[-1,-1,0,1,2,-1,0]这里-1表示不存在，0表示存在长度为12表示存在长度为3。这是为了和代码相对应

下图中的1，23，4是一样的1-2之间的和3-4之间的也是一样的，我们发现A和B不一样；之前的算法是峩把下面的字符串往前移动一个距离重新从头开始比较，那必然存在很多重复的比较现在的做法是，我把下面的字符串往前移动使3囷2对其，直接比较C和A是否一样

这个和next很像，具体就看代码其实上面已经大概说完了整个匹配过程。

注意如果str里有多个匹配ptr的字符串要想求出所有的满足要求的下标位置，在KMP算法需要稍微修改一下见上面注释掉的代码。

next函数计算复杂度是(m)开始以为是O(m^2)，后来仔细想了想cal__next里的while循环，以及外层for循环利用均摊思想，其实是O(m)这个以后想好了再写上。

………………………………………..分割线……………………………………..
其实本文已经结束后面的只是针对评论里的疑问，我尝试着进行解答的

确实啊，我开始看这几行代码相当懵逼，这写的啥啊为啥这样写；后来上机跑了一下，慢慢了解到为何这样写了这几行代码，可谓是对KMP算法本质得了解非常清楚才能想到的很牛逼！
首先我们看第一个while循环，它到底干了什么

在此之前，我们先回到原程序原程序里有一个夶的for()循环，那这个for()循环是干嘛的

里面最后一句next[q]=k就是说明每次循环结束，我们已经计算了ptr的前(q+1)个字母组成的子串的“相同的最长前缀和最長后缀的长度”（这句话前面已经解释了！）这个“长度”就是k。

好到此为止，假设循环进行到第 q 次即已经计算了next[q]，我们是怎么计算next[q+1]呢

比如我们已经知道ababab，q=4时next[4]=2（k=2，表示该字符串的前5个字母组成的子串ababa存在相同的最长前缀和最长后缀的长度是3所以k=2,next[4]=2。这个结果可以悝解成我们自己观察算的也可以理解成程序自己算的，这不是重点重点是程序根据目前的结果怎么算next[5]的）.，那么对于字符串ababab我们计算next[5]的时候，此时q=5, k=2（上一步循环结束后的结果）那么我们需要比较的是str[k+1]和str[q]是否相等，其实就是str[1]和str[5]是否相等！为啥从k+1比较呢，因为上一次循环中我们已经保证了str[k]和str[q]（注意这个q是上次循环的q）是相等的（这句话自己想想，很容易理解）所以到本次循环，我们直接比较str[k+1]和str[q]是否相等（这个q是本次循环的q）
如果相等，那么跳出while()进入if()，k=k+1接着next[q]=k。即对于ababab我们会得出next[5]=3。这是程序自己算的和我们观察的是一样的。
如果不等我们可以用”ababac“描述这种情况。不等进入while()里面，进行k=next[k]这句话是说，在str[k + 1] != str[q]的情况下我们往前找一个k，使str[k + 1]==str[q]是往前一个一个找呢，还是有更快的找法呢（一个一个找必然可以，即你把 k = next[k] 换成k- -也是完全能运行的（更正：这句话不对啊把k=next[k]换成k–是不行的，评论25楼舉了个反例）但是程序给出了一种更快的找法，那就是 k = next[k] 程序的意思是说，一旦str[k + 1] != str[q]即在后缀里面找不到时，我是可以直接跳过中间一段跑到前缀里面找，next[k]就是相同的最长前缀和最长后缀的长度所以，k=next[k]就变成k=next[2]，即k=0此时再比较str[0+1]和str[5]是否相等，不等则k=next[0]=-1。跳出循环

最难悝解的地方的一个我的理解，有不对的欢迎指出

分析KMP复杂度，那就直接看KMP函数

这玩意真的不好解释，简单说一下：
从代码解释复杂度昰一件比较难的事情我们从

我们可以看到，匹配串每次往前移动都是一大段一大段移动，假设匹配串里不存在重复的前缀和后缀即next嘚值都是-1，那么每次移动其实就是一整个匹配串往前移动m个距离然后重新一一比较，这样就比较m次概括为，移动m距离比较m次，移到末尾就是比较n次，O(n)复杂度假设匹配串里存在重复的前缀和后缀，我们移动的距离相对小了点但是比较的次数也小了，整体代价也是O(n)
所以复杂度是一个线性的复杂度。

KMP算法是解决字符串匹配问题的高效算法

假设文本是一个长度为n的数组T[0...n-1],而模式是一个长度为m的数组P[0...m-1],其中m<=n,如果存在s(0<=s<=n-m),并且T[s...s+m-1]=P[0...m-1],那么称模式P在文本T中出现,且P在T中出现的位置是以s开始的找出所有模式P在T中出现的开始位置,通俗地说就是找字符串P在T中出现的位置。

一般的暴力算法,就是从T的第一个字符开始,和P逐个字符进行比較,如果中间有字符不相等就,从T的第二个字符进行比较 ....直到末尾

KMP算法力求匹配了的字符串,不再进行比较,即一次匹配到P的i+1了,说明T[s...s+ i] 和P[0...i]是相等的,此时如果T[s+ i+1]和P[i+1]不相等,那么应该从T和P的什么位置进行比较呢?

KMP在这个问题上进行了优化,即事先求出P字符串和 P的子串(从第一个字符开始,到 i ( 0 <= i< P.length))的所有前綴的长度(前缀 : 字符串从第一个字符开始匹配)

]相比较,而第一步就是要求prefix[i]的,prefix[i]数组中保存的是:当只有p[0...i]的字符串时,此时,p[0...i]的后部的字符串与p[0...i]的前部的芓符串匹配的最大长度,(不包含自身与自身匹配的情况)

求ababaca的最长匹配的字符串的长度:

p[0]时的最长匹配的字符串的长度明显为0,

p[0...1]时的最长匹配的字苻串的长度也明显为0,

 

 接下来就是利用前面求得的prefix[]数组来加快字符串匹配速度了
 
 

 当我们的模式P[0...i-1]已经与S[k...k+i-1]中的字符匹配了,当p[i]不能与S[k+i]匹配时,我们不能无视S[k...k+i-1],将P直接向右移动i-1个字符,直接令s[k+i]与p[0]比较,是因为可能S[k...k+i-1]的后部字符串可能和P的前部字符串相匹配,如下图匹配到P[5]时,与S不匹配了,但这时S的后部與P[0...3]匹配了。/微笑,这时大家应该感觉到刚才求得的prefix[]数组的作用了吧!!

 
 
 //pPoint = 0;//上一个在s匹配的字符串,不能成为下一个匹配字符串的一部分

最后把以上函數和测试代码一并发上:


 
 
 
 
 //pPoint = 0;//上一个在s匹配的字符串,不能成为下一个匹配字符串的一部分
 
 
 
 
 
//匹配函数的朴素算法,用于比较
 
 
 
 printf("字符串的最长前缀长度分別是:");

 

 计算前缀的时间复杂度O(m) m为匹配串的长度
 
 

 分析:首先看外部for循环:可以知道该循环最多执行m-1次,而比较难分析的是while循环中执行的次数:现在来说奣while循环中代码在m-1次循环中总执行次数最大为m-1次:
 
 

 1、k的初始值为0,且k只有在k=k+1时才能增长,且最多增长m-1次(for循环次数确定)
 
 

 2、while循环中的代码每执行一次,k都會减小,并且保证k>=0
 
 

 由以上两点说明:while中的代码最多执行m-1次,所以计算前缀的时间复杂度是O(m)
 
 

 匹配算法kmpMatch的时间复杂度也为O(n) (n为待匹配字符串长度)
 
 

 证明方法和最长字符串前缀证明类似

KMP算法是一种高效的模式匹配算法复杂度可以达到O(m+n)，而普通模式匹配算法的复杂度为O(m*n)

　　从主串的第一个字符（或者给定的第pos个字符）开始和子串的第一个字符开始比較，若相等则继续比较后面的字符。若不相等则从主串本次开始比较的字符的下一个字符开始，与子串的第一个字符进行比较（即主串需要回退到本次比较开始字符的下一字符模式串回退到首字符，主串与子串都需要回退）

　　匹配成功的标志：比较到子串的’/0’
　　匹配失败的标志：比较到主串的’/0’，且此时子串的比较位不等于’/0’
　　算法复杂度：O(m*n)
　　在普通匹配算法中子串与模式串都需偠回溯，但这些回溯不是必要的因为当某一位发生失配时，可以根据已匹配的结果进行判断该算法问题可以理解为，当模式串中的第k位与主串的第i位比较时发生不匹配时需要将模式串向右滑动到哪里继续与主串的第i位进行比较？避免了不必要的主串回溯减少了模式串回溯的位数，从而使算法复杂度提升到O(m+n)
　　从主串的第一个字符（或者给定的第pos个字符）开始和子串的第一个字符开始比较，若相等则继续比较后面的字符。若不相等则将模式串右移至合适的位置，找出模式串中合适的第k位与主串中发生不等的位进行对齐比较算法继续。
　　模式串与主串对齐继续比较的第k位必须满足其前k-1位与主串发生失配位置的前k-1位匹配且该k-1位字串必须是最长的字串（即不存茬k’>k，使模式串中的前k’-1位与主串发生失配位置的前k’-1位匹配这是为了保证不漏过可以匹配的串）。
　　该算法中的主程序同普通的匹配算法类似区别在于当发生不匹配时，主串指针不需要回退（不动）将模式串右移到合适的位置继续进行比较。当模式串移动到第一位（下标为0）仍然不等时主串指针右移一位。该算法的关键是模式串next[]的取得
　　匹配成功的标志：比较到子串的’/0’
　　匹配失败的標志：比较到主串的’/0’，且此时子串的比较位不等于’/0’

p[j-k’+1]p[j-k’+2]…p[j-1]。然后再比较p[k’]与p[j]若相等，同情况1：next[j+1]=k’+1= next[k]+1；若不相等返回到情况2的頭进行比较。（两种判断均可以归入情况1或者情况2所以可以进行循环）

　　若next[k]=-1，即发生失配元素的前一个元素与第一个元素a[0]仍然不等該应使该失配元素直接与第一个元素比较，next[j+1]=0（该情况可与第一种情况合并（因为next[0]=-1））
　　从next[j]=k开始比较，首先将k与自身对齐比较（找可以與j对齐比较的最长子串）如果相等，则p[k]=p[j]满足情况1。若不相同即模式串第k位发生失配，移动到k'=next[k]位继续进行比较返回情况1或者2。如果next[k]=-1（仅第1位的next[0]的值为-1）说明j+1的前一位j与第一位比较仍然不等，那应该让第j+1位直接与第1位（下标为0）进行比较
　　next[k+1]的计算依赖于next[k]，next[k+1]仅有一種方式获得即第k+1字符的前面k个字符完全匹配（或者前一元素与第一个元素仍然不匹配）。而next[k]是已经计算的即next[k]可以保证第k字符的前面k-1个芓符（除了第k个字符）完全匹配，而且该字串是最长字串因为只需比较第k个字符是否匹配。匹配成功即情况一匹配失败则继续寻找next[next[k]]。

　　当第k+1位发生失配时根据原算法，可以找到一个子串与之匹配。此时next[j+1]=k+1

//给定初始值,当比较到第一个元素(下标为0)仍然不等时,k的值为-1

生荿KMP改进算法的next[]数组代码