字符串精确匹配KMP算法思想演变

引言

字符串匹配一直是计算机科学领域研究和应用的热门领域，算法的改进研究一直是一个十分困难的课题。作为字符串匹配中的经典算法，KMP算法一直以较高的效率和富有美感的构思闻名。本文希望由传统的精确匹配算法入手，层层推进，研究KMP算法思想的演变历程。

1.传统的精确匹配

1.1 精确匹配的含义

字符串的精确匹配就是在文本T中找出模式P的精确副本。这是一个要么完全匹配要么、完全不匹配的方法。如果模式P和T的一个子字符串非常类似，但不相同，就拒绝部分匹配。
我们首先约定一些符号：文本T是一系列符号、字符或字母，|T|表示T的长度，T(i)是T中位置i上的字符，T(i…j)是T中从位置i开始到位置j结束的子字符串，模式P(指在T中寻找匹配的字串)和文本T中的第一个字符在位置0上。另外，正则表达式a^n表示字符串a….a，其中包含n个a。

1.2 强制匹配

字符串精确匹配最简单的算法即是直观的“暴力破解”，这种称为强制匹配的算法从文本T的第一个字母和模式P的第一个字母开始比较P和T，如果不匹配，就从T的第二个字符开始和模式P的第一个字母匹配，以此类推，不保留在后续尝试中可能有用的信息。伪代码十分常见，就不在此赘述了。
在最坏情况下，强制匹配的执行时间是O(|T||P|)。

1.3 强制匹配的改进

对于强制匹配算法，1992年Hancart提出了一种称为not-so-naive算法的改进。该算法从P的第二个字符开始比较，直到P的结尾，最后比较第一个字符，所以比较过程中的字符顺序是P(1),P(2),…….,P(|P|-1),P(0)。
记录下P的前两个字符相等的信息，并在匹配过程中使用。要区分两种情况：P(0)=P(1)和P(0)!=P(1)。在第一种情况下，如果P(1)!=T(i+1)，就给文本索引i递增2，因为P(0)!=T(i+1);否则，i就递增1。这类似于第二种情况中的P(1)=T(i+1)。这样，就可以移动两个位置。
匹配从第二个字符开始。如果在P(1)和T(i+1)之间又一个不匹配的字符，则只要P的前两个字符是相同的，P就可以移动两个位置，然后开始下一次迭代，因为这种不匹配意味着P(0)和T(i+1)也是不同的。但是，当内层循环中出现不匹配之后，模式只移动一个位置。 而P的前两个字符不同时，采取的措施则相反。
在最坏情况下，该算法的执行时间是O(|T||P|)，但如Hancart所述，它的平均执行性能比起KMP、Boyer-Moore等字符串匹配算法要好。

2. KMP算法

2.1 可以改进什么？

强制算法的效率很低，因为它在找不到匹配的字符后，要把模式P移动一个位置。为了加快算法的执行速度，Hancart的算法允许移动两个字符。但是，我们应该需要一种算法，可以将P向右移动多个位置，同时不遗漏任何匹配。
强制算法效率不高的根源是进行了多余的比较。要避免这种冗余，应该注意模式P在其开头到不匹配的字符之间包含的相同的子字符串，利用这一事实，可以把P向右移动多个位置，之后开始下一次扫描。

2.2 如何改进

从上文可以看出，一般情况下，当T(K+1)与P(j+1)发生不匹配，而P(0…j)都已经完成匹配时，我们可以尝试在P(0…j)中寻找与其后缀相匹配的前缀，假设匹配的前后缀字串的长度都是len，即P(0…len-1)和P( j-len+1….j )是两个相同的字串，前缀从P的开头起始，后缀以P的结尾结束，长度都是len，它们有相同的内容。
因为P(0….j)已经完成了匹配，故T(K-len+1…K)与P(j-len+1….j)是匹配的，而P(j-len+1….j)与P(0…len-1)是匹配的。所以P(0…len-1)与T(K-len+1….K)是匹配的，当T(K+1)与P(j+1)不匹配时，我们可以不用像强制算法要求那样将P(0)与T(K-j+2)重新开始匹配，可以将P(len-1)与T(K)对齐，从P(len)与T(K+1)开始比较。
由之前的论证可以知道，这样是没有错误的，P(0…len-1)已经完成匹配。而由于P(len…j-len)中在之前的子串匹配中已知无法与T(K-len+1…K)中某一子串匹配，故无法完成模式匹配，可知P(len-1)与T(K)对齐没有遗漏或是跳过可能的模式匹配的情况。
在匹配过程中，P与T会多次不匹配，此时就需要移动P或T使之到指定的位置，上述的信息将会使用多次。因此，P应该进行预处理。重要的是，在这种方法中，只使用有关P的信息，T中字符的配置无关紧要。

定义表next：
1. 当j=0时，next[ j ]= -1；
2. 如果k存在，next[ j ]= max{k：0< k

2.3 求next数组

表next仍然没有确定，我们可以使用强制算法来确定它，对于短模式而言，效率并不算低。还可以使用KMP算法提高确定next的效率。
next包含P的匹配前缀中最长后缀的长度，即P的一些部分与P的其他部分匹配。但匹配问题已经使用KMP算法解决了，在这种情况下，P再次与其自身匹配。但是，KMP使用的是目前仍未知的next。所以，必须修改KMP算法，使之使用已经找到的值确定next的值。设next [0] = -1,假定next[ 0 ],…next[i-1],应该考虑两种情况：

• 在第一种情况下，我们要找出匹配前缀的最长后缀，只要把字符P[i-1]与对应于位置next[i-1]的后缀关联起来，当P[i-1]=P[next[i-1]]时，它为真：
  在这种情况下，当前的后缀比前面找到的后缀多一个字符，所以next[ i ] = next[ i-1 ]+1。
• 在第二种情况下，P[i-1] != P[next[ i-1 ]]。但这只是一个不匹配的字符，不匹配可以用表next做处理，这就是要确定它的原因。因为P[next[i-1]]是一个不匹配的字符，所以要检查next[next[i-1]]，确定P[i-1]是否匹配，如果匹配，就给next[i]赋值next[next[i-1]]+1。
  否则，就比较P[i-1]和P[next[next[next[i-1]]]]，如果字符匹配，就使next[ i ] = next[next[next[i-1]]]+1，否则，继续搜索，直到找到一个匹配，或达到P的开头为止。

确定表next的算法如下：

1.findNext(模式 P，表 next)
2. next[ 0 ] = -1;
3. i = 0;
4. j = -1;
5. while i < |P|
6. while j==0 或 i < |P| 且 P[i] == P[j]
7. i++;
8. j++;
9. next[ i ] = j;
10. j = next[j];


2.3 next数组的改进

如果去除不必要的比较，就可以改进Knuth-Morris-Pratt算法。如果在字符T[i]和P[j]处出现不匹配，下一次就应该尝试匹配字符T[i]和P[next[j]+1],但如果P[j]=P[next[j]+1],则还会发生不匹配，这意味着一次多余的比较。
因此，我们应该重新设计表next，去除这种多余的比较。这里可以使用扩展next定义的方法，再加上一个条件，得到一个更强健的next列表：
1. 当j=0时，next[j]=-1;
2. 如果K存在的话，next[j]=max{k:0

3.运行时间分析

为了评估Kunth-MorrisPratt()的运行时间，注意外层循环执行了O(|T|)次。而因为在每次的循环迭代中，i都递增，根据外层循环的条件，i的最大值是|T|-|P|，所以内层循环至多执行|T|-|P|。但对于不匹配的字符T[ i ]，j赋予新值的次数是k < |P|。此时，P中第一不匹配的字符与字符T[i+k]对齐。
对于i，可以执行|P|次比较，但每个i不一定都会执行|P|次比较，只有第|P|个i才会如此。所以不成功的比较次数最多为P(|T|/|P|)=|T|。给这个数字加上至多|T|-|P|次成功的比较次数，就得到了运行时间O(|T|)。
而findNext()与Kunth-MorrisPratt()十分相似，所以，可以推测出next可以在O(|P|)时间内确定。Kunth-MorrisPratt()中外层while循环的运行时间是O(T)，所以Kunth-MorrisPratt算法，包括findNext()在内，执行时间是O（|T|+|P|）。
注意，在分析这个算法的复杂度时，我们未考虑文本T和模式P中的字符，也就是说，该复杂度是独立于组成P和T的不同字符数。