假设主串：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算法代码：