关于KMP算法的分析,我觉得这两篇博客写的不错:
http://www.ruanyifeng.com/blog/2013/05/Knuth–Morris–Pratt_algorithm.html
http://blog.csdn.net/v_JULY_v/article/details/6545192
下面的笔记也是参考了这两篇博客的。
KMP算法是最有名的字符串匹配算法了。它是BF算法的改进版,至于是如何改进的,先引用上述第二篇博客里的一段话:
“在继续分析之前,咱们来思考这样一个问题:为什么快排或者堆排序比直接的选择排序快?直接的选择排序,每次都是重复地比较数值的大小,每扫描一次,只得出一个最大(小值),再没有其它的成果。而快排,每扫一次,将数据分成了两部分,右边的数据都大于左边的数据,所以在下一次比较的时候,这两部分元素之间就不用比较了。再看堆排序,建堆的过程也是O(n)的比较,但比较的结果得到了最大(小)堆这种三角关系,之后的比较就不用再每一个都需要比较了。
由上述思考,咱们总结出了一点优化的归律:采用一种简单的数据结构或者方式,将每次重复性的工作得到的信息记录得尽量多,方便下一次做同样的工作,这样将带来一定的优化。”
总结上面这段话的核心思想,就是把循环中要重复做的工作提取到循环外完成,从而提高效率。
下面用一个例子演示KMP匹配的过程。其中涉及的三个数据如下:
source:源串,即要匹配的母船
pattern:模式串,即子串
next数组:其每个元素对应pattern的每个字符,表示当该字符pattern[j]不匹配source[i]时,应该从pattern的哪个下标开始重新匹配当前的source[i],具体求法后面介绍
本例中source为ABCABCABDE,pattern为ABCABD,第一次匹配,前5个字符均匹配成功,匹配第6个字符时如下:
此时发现source[5]和pattern[5]不匹配,BF算法的做法是从source[1]开始从新匹配pattern,即像下面这样:
而KMP算法则不会再去重新比较source[1...4]了,它会利用next的信息调整pattern。因为next[5]=2,所以下一次匹配将当前的source[5]和pattern[2]比较,即像下面这样:
这时发现source[5]和pattern[2]匹配,继续往下比较,直至pattern中所以元素都比较完了,如下:
此时已经在母串中找到了子串,i=9,m=6,所以返回的下标为i-m=3。
这样整个匹配过程就完了,感觉不过瘾吗,前面两篇推荐的博客里有更长的匹配串分析。
把上面的过程翻译成代码,也就是KMP算法的实现,如下:
int KMP(char *source, char *pattern) { int i, j, m, n; int *next; i = 0; j = 0; m = strlen(pattern); n = strlen(source); next = (int *)malloc(m * sizeof(int)); Next(pattern, next);<span style="white-space:pre"> </span>// 这是求next数组的函数,后面解释 while (i < n && j < m) { if (j == -1 || source[i] == pattern[j]) { ++i; ++j; } else { j = next[j]; } } free(next); if (j == m) { return i - m; } else { return -1; } }
下面来看next数组是如何求得的。
如前所述,next数组里保存的就是pattern[j]与母串中的字符不匹配时,该用哪个下标继续和这个字符匹配。若next[j]=k,则有:pattern[0...k-1] = pattern[j-k...j-1],而且这个k是最大的,即不会有pattern[0...k] =pattern[j-k-1...j-1]。
反过来想,如果已经知道了pattern[0...k-1] = pattern[j-k...j-1],next[j]是多少呢?要分两种情况考虑:
1. pattern[k] != pattern[j],则next[j] = k
2. pattern[k] = pattern[j],则next[j] = next[k]
第二种情况是因为,若pattern[k] = pattern[j]时,也使next[j]=k;则在pattern[j]于母串不匹配的情况下,再拿pattern[next[j]]即pattern[k]去比较的话,肯定也是不匹配的。这是隐藏的重复工作。使next[j] = next[k]就能避免这种重复工作。
那么怎么又能保证pattern[j]不会等于pattern[next[k]]呢?不急,一步一步想:最开始有next[0]=-1,如果pattern[1]=pattern[0],那么由规则2,next[1]=next[0]=-1;再如果pattern[2]=pattern[1],那么next[2]=next[1]=-1。看到了吗,三个一样的字符,如果是next依次为前一个元素的情况,最终都会是最前面那个next值,这就保证了最大的减少重复工作。
好吧,上面的解释很挫,意会吧。其实就跟离散树一样,同一个集合的元素都有相同的根。
有了上面的规则后,求next数组就比较方便了。用动态规划的策略很好实现:
void Next(char *pattern, int *next) { int i, j, n; i = 0; j = -1; next[0] = -1; n = strlen(pattern); while (i < n - 1) { if (j == -1 || pattern[i] == pattern[j]) { ++i; ++j; if (pattern[i] != pattern[j]) { next[i] = j; } else { next[i] = next[j]; } } else { j = next[j]; } } }
是不是感觉和KMP的框架很像,其实就是一回事,都是子串匹配,都利用了next数组。
不同之处在于:KMP是source匹配pattern,Next是一直从pattern的头部开始匹配后面所有的序列;在Next里面,next数组还没有完全生成,是利用前面生成的next加上匹配结果生成下一个next,这就是动规的策略。