数据结构与算法之KMP算法

KMP算法追溯

KMP算法是比较著名的匹配算法，是油D.E.Knuth,J.H.Morrs和VR.Pratt,发表的一个模式匹配算法可大大避免重复遍历的情况

KMP模式匹配算法原理

假设,主串S=“abcdefgab”;模式串T=“abcdex

如果使用暴风算法，前面5个字母完全相等，直到第6个字母f和x不相等

紧接着需要执行以下的过程，即主串i = 2，3，4，5，6时，首字母子串的首字母均不相等

如果按照爆发算法的设计，便需要执行这样的过程，但对于要匹配的子串T来讲，"abcdex"首字母与后面的串”bcdex“中的任意一个字符都不相等，实则既然“a”不与自己后面的子串中任意一个字符相等，那么对于图1中来说，前面5个字符分别相等，就意味着子串T与首字母“a”不可能与S串的第二位到第5位相等，这样以来图1、2、3的判断便是多余的。

KMP算法便是利用已知信息，不要把搜索位置移回到已经比过的位置，继续把其向后移，这样便提高来效率。

KMP 模式匹配算法原理探索

如果知道T串中的首字母“a”与T中后面的字符均不相等，并且T串的第二位“b”与S串中的第二位“b”在图1中已经判断相等。这就意味着T串中的首字符“a”与S串中的第二位“b”是不需要判断的，也知道其是不可能相等，这样以来图2便可以省了。

KMP 模式匹配算法_next 数组值推导

• 当 j = 1时, next[1] = 0 
• 当 j=2时, j 由 1到 j-1 范围内只有字符 “a”, 属于其他情况 next[2] = 1;
• 当 j=3时, j 由 1到 j-1 范围内有字符 “ab”,显然 a 不等于 b, 属于其他情况 next[3] = 1;
• 当 j=4时, j 由 1到 j-1 范围内有字符”abc”,显然abc 不存在相等情况,则属于其他情况
  next[4] = 1;
• 当 j=5时, j 由 1到 j-1 范围内有字符”abcd”,显然abcd 不存在相等情况,则属于其他情况
  next[5] = 1;
• 当 j=6时, j 由 1到 j-1 范围内有字符”abcde”,显然abcde 不存在相等情况,则属于其他情
  况next[6] = 1;  

解读分析：

• 当j=5时,j由1到j-1范围内有字符”abca”,显然abca前缀字符“a”与后缀字符，a”相等;(由于’p1…pk-1’=‘pj-k+1...pj-1      因此可以推算出k值为2;因此next[5]=2;
• 当j=6时,j由1到j-1范围内有字符”abcab”,显然abcab前缀字符“ab”与后缀字符,“ab”相等;(由于’p1…pk-1’=‘pj-k+1…p j-1j-1，得到[p1,p3-1]=[p6-3+1,p5])推导k值为3,因此next[6]=3。

所以：如果前后缀一个字符相等,K值是2;两个字符相等是3;n个相等k值就是n+1;

假设,主串S=“abcababca”;模式串T=“abcdex”

KMP模式匹配算法_next数组值推导—理解回溯

1. 默认next[1]=0 
   
2. i=0,j=1开始遍历
   
3. 当j<T.lengthj从1~length遍历字符串;
   
4. 如果当i=0表示[i,j]这个范围内没有找到相同的字符,所以i要回溯到1的位置;表示next[j]=i;
   
5. 如果当T[i]=T[j]相等,表示找到与其相同字符的位置,所以next[j]=i;
   
6. 当以上2个条件都不满⾜,则将i回溯到前⾯记录的next[i]的位置;

• 比较 T[i] != T[j] 但是 i = 0 ; 则表示[0,1]这 个范围[a] 只能从1的位置开始;  
• j++, i++,所以 i = 1, j = 2; 
• 并且更新next[j] = i; 则next[2] = 1; 
  

• 此时⽐比较 [1,3] 这个范围是否存在相等字符 出现;
  

• T[i] != T[j] 所以i 的位置⼜又要回退.
  

• i = next[1] = 0; 此时 i = 0; 

• 此时⽐较 [0,3] 这个范围是否存在相等字符 出现;
• 因为 出现 i=0, 也就是字符串串⽐比较⼜又要重头 开始,则 i++,j++; i=1, j = 4;
• next[j] = i; next[4] = 1; 

KMP模式匹配算法 匹配函数的实现 

问题

     假设, 主串S = “aaaabcde” ; 模式串 T = “aaaaax” 问题1: 此时模式串 T 的next 数组为? 

T = "abababaaba"

默认next[1] = 0;  T[i] == T[j] 且++i,++j 后 T[i] 依旧等于 T[j] 则 nextval[i] = nextval[j]i = 0, 表示从头开始i++,j++后,且T[i] != T[j] 则nextVal = j;T[i] == T[j] 且++i,++j 后 T[i] != T[j] ,则nextVal = j; 

#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0#

define MAXSIZE 100    /* 存储空间初始分配量 */
typedef int Status;   /*是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType; /* ElemType类型根据实际情况而定，这里假设为int */
typedef char String[MAXSIZE+1]; /*  0号单元存放串的长度 */
//----字符串相关操作---
/* 生成一个其值等于chars的串T */
Status StrAssign(String T,char *chars){  
   int i;   
   if(strlen(chars)>MAXSIZE)      
       return ERROR;    
    else    {     
       T[0]=strlen(chars);  
       for(i=1;i<=T[0];i++)          
       T[i]=*(chars+i-1);    
       return OK;  
    }
}

Status ClearString(String S){  
   S[0]=0;/*  令串长为零 */   
   return OK;
}

/*  输出字符串T。 */
void StrPrint(String T)
{
    int i;
    for(i=1;i<=T[0];i++)
        printf("%c",T[i]);
    printf("\n");
}

/* 返回串的元素个数 */
int StrLength(String S)
{
    return S[0];
}

//----KMP 模式匹配算法---
//1.通过计算返回子串T的next数组;
//注意字符串T[0]中是存储的字符串长度; 真正的字符内容从T[1]开始;
void get_next(String T,int *next){
    int i,j;
    j = 1;
    i = 0;
    next[1] = 0;
    //abcdex
    //遍历T模式串, 此时T[0]为模式串T的长度;
    //printf("length = %d\n",T[0]);
    while (j < T[0]) {
        //printf("i = %d j = %d\n",i,j);
        if(i ==0 || T[i] == T[j]){
            //T[i] 表示后缀的单个字符;
            //T[j] 表示前缀的单个字符;
            ++i;
            ++j;
            next[j] = i;
            //printf("next[%d]=%d\n",j,next[j]);
        }else
        {
            //如果字符不相同,则i值回溯;
            i = next[i];
        }
    }
}

//输出Next数组值
void NextPrint(int next[],int length)
{
    int i;
    for(i=1;i<=length;i++)
        printf("%d",next[i]);
    printf("\n");
}

int count = 0;
//KMP 匹配算法(1)
//返回子串T在主串S中第pos个字符之后的位置, 如不存在则返回0;
int Index_KMP(String S,String T,int pos){
    
    //i 是主串当前位置的下标准,j是模式串当前位置的下标准
    int i = pos;
    int j = 1;
    
    //定义一个空的next数组;
    int next[MAXSIZE];
    
    //对T串进行分析,得到next数组;
    get_next(T, next);
    count = 0;
    //注意: T[0] 和 S[0] 存储的是字符串T与字符串S的长度;
    //若i小于S长度并且j小于T的长度是循环继续;
    while (i <= S[0] && j <= T[0]) {
        
        //如果两字母相等则继续,并且j++,i++
        if(j == 0 || S[i] == T[j]){
            i++;
            j++;
        }else{
            //如果不匹配时,j回退到合适的位置,i值不变;
            j = next[j];
        }
    }
    
    if (j > T[0]) {
        return i-T[0];
    }else{
        return -1;
    }
    
}

//KMP 匹配算法(2)
//求模式串T的next函数值修正值并存入nextval数组中;
void get_nextVal(String T,int *nextVal){
    int i,j;
    j = 1;
    i = 0;
    nextVal[1] = 0;
    while (j < T[0]) {
        if (i == 0 || T[i] == T[j]) {
            ++j;
            ++i;
            //如果当前字符与前缀不同,则当前的j为nextVal 在i的位置的值
            if(T[i] != T[j])
                nextVal[j] = i;
            else
            //如果当前字符与前缀相同,则将前缀的nextVal 值赋值给nextVal 在i的位置
                nextVal[j] = nextVal[i];
        }else{
            i = nextVal[i];
        }
    }
}

//KMP 匹配算法(3)
//返回子串T在主串S中第pos个字符之后的位置, 如不存在则返回0;
int Index_KMP2(String S,String T,int pos){
    
    //i 是主串当前位置的下标准,j是模式串当前位置的下标准
    int i = pos;
    int j = 1;
    
    //定义一个空的next数组;
    int next[MAXSIZE];
    
    //对T串进行分析,得到next数组;
    get_nextVal(T, next);
    count = 0;
    //注意: T[0] 和 S[0] 存储的是字符串T与字符串S的长度;
    //若i小于S长度并且j小于T的长度是循环继续;
    while (i <= S[0] && j <= T[0]) {
        
        //如果两字母相等则继续,并且j++,i++
        if(j == 0 || S[i] == T[j]){
            i++;
            j++;
        }else{
            //如果不匹配时,j回退到合适的位置,i值不变;
            j = next[j];
        }
    }
    
    if (j > T[0]) {
        return i-T[0];
    }else{
        return -1;
    }
    
}


int main(int argc, const char * argv[]) {
    printf("Hello, KMP匹配算法的实现!\n");
    int i,*p,*t;
    String s1,s2;
    int Status;
    
    /*关于next数组的求解*/
    StrAssign(s1,"aaaaax");
    printf("子串为: ");
    StrPrint(s1);
    i=StrLength(s1);
    p=(int*)malloc((i+1)*sizeof(int));
    get_next(s1,p);
    printf("Next为: ");
    NextPrint(p,StrLength(s1));
    t=(int*)malloc((i+1)*sizeof(int));
    get_nextVal(s1, t);
    printf("NextVal为: ");
    NextPrint(t,StrLength(s1));
    printf("\n");
    
    //KMP算法调用
    StrAssign(s1,"abcababca");
    printf("主串为: ");
    StrPrint(s1);
    StrAssign(s2,"abcdex");
    printf("子串为: ");
    StrPrint(s2);
    Status = Index_KMP(s1,s2,1);
    printf("主串和子串在第%d个字符处首次匹配（KMP算法）[返回位置为负数表示没有匹配] \n",Status);
    Status = Index_KMP2(s1, s2, 1);
    printf("主串和子串在第%d个字符处首次匹配（KMP_2算法）[返回位置为负数表示没有匹配] \n\n",Status);
    
    StrAssign(s1,"abccabcceabc");
    printf("主串为: ");
    StrPrint(s1);
    StrAssign(s2,"abcce");
    printf("子串为: ");
    StrPrint(s2);
    Status = Index_KMP(s1,s2,1);
    printf("主串和子串在第%d个字符处首次匹配（KMP算法）[返回位置为负数表示没有匹配] \n",Status);
    Status = Index_KMP2(s1, s2, 1);
    printf("主串和子串在第%d个字符处首次匹配（KMP_2算法）[返回位置为负数表示没有匹配] \n\n",Status);
    
    StrAssign(s1,"aaaabcde");
    printf("主串为: ");
    StrPrint(s1);
    StrAssign(s2,"aaaaax");
    printf("子串为: ");
    StrPrint(s2);
    Status = Index_KMP(s1,s2,1);
    printf("主串和子串在第%d个字符处首次匹配（KMP算法）[返回位置为负数表示没有匹配] \n",Status);
    Status = Index_KMP2(s1, s2, 1);
    printf("主串和子串在第%d个字符处首次匹配（KMP_2算法）[返回位置为负数表示没有匹配] \n\n",Status);
    
    return 0;
}

打印结果：