查找子字符串----KMP算法深入剖析

假设主串：a b a b c a b c a c b a b
      子串：a b c a c

1、一般匹配算法

逐个字符的比较，匹配过程如下：
　　第一趟匹配
　　a b a b c a b c a c b a b
　　a b c
　　第二趟
　　a b a b c a b c a c b a b
　    a
　　第三趟
　　a b a b c a b c a c b a b
　　    a b c a c
　　第四趟
　　a b a b c a b c a c b a b
　　      a
　　第五趟
　　a b a b c a b c a c b a b
　          a
　　第六趟
　　a b a b c a b c a c b a b
　　          a b c a c

匹配成功。

性能分析：情况好：时间复杂度O(m+n)；情况差：时间复杂度O(m*n)。　　

2、一般匹配算法改进

　　即KMP算法。可以发现上面的算法，每一趟匹配过程中出现字符不等时，回溯指针，如果将其改进，指针不回溯，利用已经得到的部分匹配的结果将模式向右移动的更远一些，然后继续比较。那么算法性能会得到大大的提高。
　　看到上面的过程，在第三趟的匹配过程中，当i=6,j=4字符不等时，又从i=3,j=0重新开始比较。其实可以容易发现,在i=3和 j=0，i=4和i=0以及i=5和j=0这3次比较都是不必进行的。因为从第三趟部分匹配结果就可以得出，主串中第3,4,5个字符是’b’,’c’,’a’。而模式中第一个字符是’a’，因此无需和这3个字符进行比较了，紧需要向右移动3个字符继续进行i=6,j=1时字符串比较就行了。那么一种理想的模式匹配就可以的出来了。

KMP匹配过程如下：
　　第一趟
　　a b a b c a b c a c b a b
　　a b c
　　第二趟
　　a b a b c a b c a c b a b
　　    a b c a c
　　第三趟
　　a b a b c a b c a c b a b
　　          a b c a c 
匹配成功，可以看出算法效率提高了不少。

3、剖析KMP算法：

假设(n>m)
　　主串：s0 s1 s2 s3 s4 s5 s6 …… s(n)
　　模式：p0 p1 p2 p3 p4……….p(m)      
当匹配过程中产生失配（s(i)!=p(j)）时，主串的第i个字符应与模式中的哪个字符相比较？假设此时与模式中的第k（k<j）个字符相比较，那么就有p0p1…p(k-1)=s(i-k)s(i-k+1)…s(i-1) --式1(就好像上面中绿的的字符a,这里是从模式中第1个字符开始比较与主串中字符a相同)。
　　当匹配失配时（s(i)!=p(j)）,可以得到p0p1p2p3…p(j-1)=s(i-j)s(i-j+1)…s(i-1) --式2
　　从式2可以得到p(j-k)p(j-k+1)…p(j-1)=s(i-k)s(i-k+1)..s(i-1) --式3
　　由式1和式3可以得到p0p1…p(k-1)=p(j-k)p(j-k+1)…p(j-1) --式4
　　若令next[j]=k，则next[j]表明当模式中第j个字符与主串中相应字符失配时，在模式中需要重新和主串中该字符进行比较的字符位置。那么next 函数定义为：
                     （1）-1 当j=0时
　　next[j]= （2）max{k|0<k<j 且式4成立}
                     （3）0  其他情况
那么此时next值如何求得呢？

由定义知道next[0]=-1;设next[j]=k，这表明在模式串中有这样关系p0p1…p(k-1)=p(j-k)p(j-k+1)…p(j-1) （0<k<j） --式5。此时next[j+1]的值有两中情况：
   （1）若p(k)=p(j), 则：p0p1…p(k)=p(j-k)p(j-k+1)…p(j) --式6，即next[j+1]=k+1。
   （2）若p(k)!=p(j),则：p0p1…p(k)!=p(j-k)p(j-k+1)…p(j)--式7，此时可以把该问题看成模式匹配的问题，整个模式串既是主串又是模式串，这里应将模式向右移动next[k](模式中第k个字符与主串失配时，需要移动的位置)位置，和主串中的第j个字符相比较。若next[k]=k’,且p(j)=p(k’),则可以得到next[j+1]=next[k]+1即 next[j+1]=next[next[j]]+1。那么还要注意下当模式中上一个字符串与下一个字符串相等时候，它们next值是相等的。

4、KMP算法代码：

1. #include "stdafx.h"
2. #include "iostream.h"
3. #include "string.h"
4. //next数组
5. void GetNext(char *subStr,int *next)
6. {
7. int len=strlen(subStr);
8. next[0]=-1;
9. int i=0,j=-1;
10. while(i<len)
11. {
12. if(j==-1||subStr[i]==subStr[j])
13. {
14. i++;
15. j++;
16. //前后缀字符相等
17. if(subStr[i]==subStr[j])
18. next[i]=next[j];
19. else
20. next[i]=j;
21. }
22. else
23. j=next[j];
24. }
25. }
26. //KMP算法
27. int KMP(char *str,char *subStr)
28. {
29. int lenStr=strlen(str);
30. int lenSubstr=strlen(subStr);
31. int i=0,j=0;
32. int *next=new int[lenStr];
33. GetNext(subStr,next);
34. //遍历主串和子串
35. while(i<lenStr&&j<lenSubstr)
36. {
37. //与一般匹配算法增加了j==-1判断
38. if(j==-1||str[i]==subStr[j])
39. {
40. i++;
41. j++;
42. }
43. //j回溯，i不变
44. else
45. j=next[j];
46. }
47. delete[] next;
48. //返回子串的位置
49. if(j>=lenSubstr)
50. return i-lenSubstr;
51. else
52. return -1;
53. }
54. int main()
55. {
56. char *str="iloveyouoooyouloveme";
57. char *subStr1="youoooyou";
58. char *subStr2="youoooyou2";
59. cout<<KMP(str,subStr1)<<endl;
60. cout<<KMP(str,subStr2)<<endl;
61. return 0;
62. }