再看数据结构之KMP匹配

KMP算法是一种改进的字符串匹配算法，由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此人们称它为克努特–莫里斯–普拉特操作(简称KMP算法)。KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。
假设主串与子串在子串第j个字符上，主串第i个字符上匹配不成功，那么如果存在(1<k<j)，使得P1P2…Pk-1 = Pj-k+1Pj-k+2…Pj-1,那么将子串的k个字符与第i个字符对齐，跳过了k-1个字符，而跳过的这些字符信息就是根据模式串自身包含的信息所得到的。
推导过程如下：
假设存在这样的(1<k<j)，那么可以推导出:
P1P2…Pk-1=Si-k+1Si-k+2…Si-1 (1)
而根据已经匹配的信息有:
Pj-k+1Pj-k+2…Pj-1=Si-k+1Si-k+2…Si-1 (2)
即可推出:
P1P2…Pk-1 = Pj-k+1Pj-k+2…Pj-1 (3)
那么如何推导出模式字符串的next[]值呢，假设对于模式字符串第j个字符，有
P1P2…Pk-1= Pj-k+1Pj-k+2…Pj-1
对于第j+1个字符，如果Pj=Pk，那么显而易见，next[j+1]=k+1=next[j]+1;当Pj！=Pk 时，那么滑动模式串，使得模式串第k个字符与第j个字符对齐，此时k’=next[k],比较Pk’与Pj个字符，如果相同，next[j+1]=k’+1=next[k]+1;如果不同继续滑动字符串，使得k”=next[k’],比较Pk”与Pj个字符，如此递推。代码如下：

#include <stdio.h>
void get_next(char *String, int next[]){
    char *s=String;
    int k=-1,j=0;   next[0]=-1;
    while(*s!='\0'){
        if(k==-1||String[j]==String[k]) { ++k ; ++j; ++s; next[j]=k;}
        else k=next[k]; 
    }
}


int KMP(char *host,char *pattern){
    int i=-1,j=-1;
    int lenHost = strlen(host);
    int lenPa = strlen(pattern);
    int next[lenPa];
    get_next(pattern,next);
    while(i<lenHost&&j<lenPa){
        if(j==-1||host[i] == pattern[j]){
            ++i; ++j;   
        }else{
            j=next[j];
        }
    }
    if(j==lenPa) return i-lenPa;
    return -1;
}

同时我们可以继续往下分析，当判断Pk不等于Pj时，则判断Pnext[k]是否与Pj相等，由之前得到的信息可得Pnext[k]=Pk,所以需要再次滑动，直到Pnext[k’]!=Pk’,即上一个不匹配的位置，所以代码可以做进一步优化：

#include <stdio.h>
void get_next(char *String, int next[]){
    char *s=String;
    int k=-1,j=0;   next[0]=-1;
    while(*s!='\0'){
        if(k==-1||String[j]==String[k]) { 
            ++k ; ++j; ++s;
            if(String[j]==String[k]) next[j]=next[k];
            else next[j]=k;
        }
        else k=next[k]; 
    }
}