解析KMP算法

       

       字符串匹配的算法当属KMP最为著名了，人人皆知，但是KMP算法是如何做到高效率字符串匹配的呢？

    我们首先来看看一般的暴力的字符串匹配算法，对于串s和模式串pattern，依次枚举s中的每一个字符作为起点与pattern尝试进行匹配，直到遇到不匹配的字符的时候，取下一个s中的字符作为起点与模式串pattern重新进行匹配。我们知道这样的时间复杂度是O(n*m)的，显然效率很不好。

    从上面暴力匹配的过程我们可以知道，当暴力进行匹配的时候，遇到不匹配的字符，不一定要从s的下一个字符重新与模式串进行匹配，那么我们如何做到这一点呢？这就要用到KMP中神奇的next数组了。

    next数组记录的是模式串的特征，从而当匹配不成功的时候，我们不一定完全对s的下一个字符与模式串从头开始匹配。于是next[i]表示当i与s中的某个串匹配不成功的时候，我们应该用第next[i]的字符与s中的当前位进行匹配。也就是说模式串pattern的子串[pattern[0], pattern[next[k]-1]]与子串[pattern[k-next[k]], pattern[k-1]]完全相同。

    我们为什么能将next数组用在与s的匹配过程中呢？因为当s[i]与patter[k]不匹配的时候，说明pattern的子串[pattern[0], pattern[k-1]]已经与s的子串[s[i-k], s[i-1]]完全匹配了，而这个时候借助next数组，我们知道如果pattern有一个前缀与s[0, i-1]的某一个后缀完全相同，我们就应该将前缀的最后一个字符的后面一个字符同s[i]进行尝试匹配。这样子大大的减少了没有作用的盲目匹配尝试。

    我们可以预见KMP算法的均摊复杂度是O(n+m)，为什么呢？因为你的s串是不会回退的，因此最多访问了n次，而模式串pattern在每一次匹配中的走动均摊下来近似为O(m)的，因此总的复杂度为O(n+m)。

    下面贴上我的KMP算法的模板，如果模式串在s中出现，则返回子串第一次出现的位置，否则返回-1。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;
const int kMax1 = 1000010;
const int kMax2 = 10010;
char g_pattern[kMax2];
char g_s[kMax1];
int g_next[kMax2];

void GetNext(int n)
{
    memset(g_next, -1, sizeof(g_next));
    g_next[0] = -1;
    g_next[1] = 0;
    int k = 0;
    int i = 1;
    while(i<(n-1))
    {
        //printf("i=%d, k=%d\n", i, k);
        if(k == -1 || g_pattern[k] == g_pattern[i])
        {
            ++i; ++k;
            g_next[i] = k;
        }
        else
            k = g_next[k];
    }
}

int KMP(int n)
{
    int ans = -1;
    int i = 0;
    int j = 0;
    int pattern_len = strlen(g_pattern);
    while(i < n)
    {
        if(j == -1 || g_s[i] == g_pattern[j])
        {
            ++i; ++j;
        }
        else
            j = g_next[j];
        if(j == pattern_len)
        {
            ans = i - pattern_len;
            break;
        }
    }
    return ans;
}

       该篇博文关于KMP算法的理解和代码，都是自己参照数据结构与算法的书上面的一点理解。而代码之前自己写的方式不一样，为了规范和容易阅读，参考了网上的代码，这个代码肯定是没有问题的，初学者可以放心的拿去当做模板使用。

    最后如果牛人发现了本博文存在纰漏，望牛人不吝赐教，我定当认真改过。