KMP字符串匹配算法

       KMP算法是一种改进的字符串匹配算法。KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next函数，函数本身包含了模式串的局部匹配信息。时间复杂度O(m+n)。

基本思想
设主串(下文中称为T)：a b a c a a b a c a b a a b b
模式串(下文中称为W)：a b a c a b
   
       用朴素(暴力)算法匹配字符串过程中，我们会把T[0]跟W[0]匹配，如果相同则匹配下一个字符，直到出现不相同的情况，此时我们会丢弃前面的匹配信息，然后把T[1]跟W[0]匹配，循环进行，直到主串结束，或者出现匹配成功的情况。这种丢弃前面的匹配信息的方法，极大地降低了匹配效率。
       而在KMP算法中，对于每一个模式串我们会事先计算出模式串的内部匹配信息，称为部分匹配表，在匹配失败时最大的移动模式串，以减少匹配次数。

前缀与后缀
在KMP算法中，用到字符串的前缀与后缀概念。通过一个例子来看一下前缀和后缀。
设有一个字符串为"google"：
前缀："g"、"go"、"goo"、"goog"、"googl"
后缀："e"、"le"、"gle"、"ogle"、"oogle"

部分匹配表
部分匹配表是指在同一(子)模式中匹配前缀和后缀中最长的模式。
下面是一个例子，求ABCDABD的部分匹配表
字符串：ABCDABD
匹配表：0000120
"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,BCD,CD,D]，共有元素为"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

KMP字符串匹配过程
问题：求字符串BBCABCDABABCDABCDABDE中是否包含字符串ABCDABD
1、BBCABCDABABCDABCDABDE
     ABCDABD
第一个字符不匹配，将搜索词后移一位
2、BBCABCDABABCDABCDABDE
       ABCDABD
还不匹配，继续后移一位...
3、BBCABCDABABCDABCDABDE
            ABCDABD
此时看到第一位匹配，继续往后看，发现ABCDAB匹配，而D不匹配。如果是朴素匹配法的话是将搜索词整个后移一位。但KMP算法是借鉴部分匹配表的信息。由于前面"ABCDAB"是匹配的。查表可知最后一个匹配字符B对应的匹配值是2，由下面公式：移动位数=已匹配的字符数 - 对应的部分匹配值。因为6-2等于4，因此将搜索词往后移动4位。
4、BBCABCDABABCDABCDABDE
                     ABCDABD
此时第三位又不匹配，此时有2位匹配，查表可知为0，因此移动2-0=2位。
5、BBCABCDABABCDABCDABDE
                          ABCDABD
此时前6位匹配，再次查表为2，因此移动6-2=4位。
6、BBCABCDABABCDABCDABDE
                                   ABCDABD
我们发现此时搜索词ABCDABD全部匹配，因此匹配成功。

next数组问题
下面是求next数组与nextval数组的两个示例：
1、求字符串'ababaaababaa'的next数组为：011234223456
next数组的求解方法：
先计算前缀next[i]的值：字符串匹配是从头开始的前缀 和 从尾开始的后缀字符串 匹配是否重复

next[i]的值主要是看s[i]之前的字符串中重复的子串长度。next[0]=-1,定值。
next[1]是看s[1]之前的字符串"a"中重复的子串长度为0，故next[1]=0;
next[2]是看s[2]之前的字符串"ab"中重复的子串长度为0，故next[2]=0;
next[3]是看s[3]之前的字符串"aba"中重复的子串长度，前缀"ab"中"a"与后缀"ba"中的"b"重复，故next[3]=1;
next[4]是看s[4]之前的字符串"abab"中重复的子串长度，前缀"aba"中"ab"与后缀"bab"中的"ab"重复，故next[4]=2;
next[5]是看s[5]之前的字符串"ababa"中重复的子串长度，前缀"abab"中"aba"与后缀"baba"中的"aba"重复，故next[5]=3;
next[6]是看s[6]之前的字符串"ababaa"中重复的子串长度，前缀"ababa"中"a"与后缀"babaa"中的"a"重复，故next[6]=1;
根据以上原则，next[7]、next[8]、next[9]、next[10]、next[11]分别为1、2、3、4、5
然后next[i]+1为：011234223456


2、求字符串'ababaabab'的nextval为：010104101
用同样的方法求next数组为：-100123123
nextval[i]的求解需要比较s中next[i]所在位置的字符是否与s[i]的字符一致。如果一致则用s[next[i]]的nextval值作nextval[i]，如果不一致，则用next[i]作为nextval[i]。

nextval[0]等于-1,和next[0]的值一样
nextval[1]，比较s[next[1]]与s[1]，s[next[1]]=a,s[1]=b，不一致，则nextval[1]=next[1]=0
nextval[2]，比较s[next[2]]与s[2]，s[next[2]]=a,s[2]=a，一致，则nextval[2]=nextval[s[next[2]]]=nextval[s[0]]=-1
nextval[3]，比较s[next[3]]与s[3]，s[next[3]]=b,s[3]=b，一致，则nextval[3]=nextval[s[next[3]]]=nextval[s[1]]=0
nextval[4]，比较s[next[4]]与s[4]，s[next[2]]=a,s[4]=a，一致，则nextval[4]=nextval[s[next[4]]]=nextval[s[2]]=-1
nextval[5]，比较s[next[5]]与s[5]，s[next[5]]=b,s[5]=a，不一致，则nextval[5]=next[5]=3
同求nextval[6]、nextval[7]、nextval[8]分别为0，-1,0。
这里nextval的下标是从-1开始，如果从1开始，则其余各位均+1,nextval为010104101

下面是实现伪代码：

algorithm kmp_search:
    input:
        an array of characters, S (the text to be searched)
        an array of characters, W (the word sought)
    output:
        an array of integers, P (positions in S at which W is found)
        an integer, nP (number of positions)

    define variables:
        an integer, j ← 0 (the position of the current character in S)
        an integer, k ← 0 (the position of the current character in W)
        an array of integers, T (the table, computed elsewhere)

    let nP ← 0

    while j < length(S) do
        if W[k] = S[j] then
            let j ← j + 1
            let k ← k + 1
            if k = length(W) then
                (occurrence found, if only first occurrence is needed, m may be returned here)
                let P[nP] ← j - k, nP ← nP + 1
                let k ← T[k] (T[length(W)] can't be -1)
        else
            let k ← T[k]
            if k < 0 then
                let j ← j + 1
                let k ← k + 1