数据结构学习(七)、串的匹配算法

　　子串的定位操作通常称为串的模式匹配，应该算是串中的最重要的操作之一。

　　我们思考下算法，然后设计函数。假设主串 S=It's a fine day，子串T=fine。我们要寻找sub在s1中的首个出现位置；

　　1、设i,j分别S,T当前下标,其中j=1；

　　2、若S[i]=T[j=1] 则可能子串开始，此时主串、子串下标加1，仅当连续四次相等则找到fine，否则主串下标退回到首次匹配的下一位，子串下标为1；

　　3、仅当连续四次相等j大于子串T的长度。

　　

/*
    返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0
*/
int Index(String S,String T,int pos)
{
    int i;
    int j;
    i = pos;
    j = 1;
    while(i<=S[0] && j<=T[0]){
        if(S[i]==T[j]){
            i++;
            j++;
        }else{
            i = i-j+2;
            j = 1;
        }
    }
    if(j>T[0])
        return i-T[0];
    else
        return 0;
}

假如：S=“0000000000000000000000000000000001”，T=“000000000000001”；在匹配的时候，每次都得到最后一位才发现原来他们不匹配，这样的效率很低。于是又三位前辈

发表了一个模式匹配算法，可以大大避免重复遍历的情况，我们把他称之为克努特-莫里斯-普拉特算法，简称KMP算法。

KMP算法

/* 通过计算返回子串T的next数组 */
void get_next(String T,int *next)
{
    int i,j;
    i=1;
    j=0;
    next[1] = 0;
    while(i<T[0]){
        if(j==0 || T[i] == T[j]){/*T[i]表示后缀的单个字符*/
            ++i;                        /*T[j]表示前缀单个字符*/
            ++j;
            next[i]=j;
        }else{
            j = next[j]; /*若字符不相等，则j值回溯*/
        }
    }
}
/* 返回子串T在主串S中第pos个位置之后的位置，若不存在则返回0*/
int Index_KMP(String S,String T,int pos)
{
    int i = pos;
    int j=1;
    int next[255];
    get_next(T,next);
    while(i<=S[0] && j<=T[0]){
        if(j==0 || S[i]==T[j]){
            j++;
            i++;
        }else{
            j = next[j]; /* j退回到合适的位置，i值不变 */
        }
    }
    if(j>T[0])
        return i - T[0];
    else
        return 0;
}        

优化KMP

void get_nextval(String S,int nextval)
{
   int i=1;
   int j=0;
  while(i<T[0]){
     if(j==0 || T[i]==T[j]){
        i++;
        j++;
        if(T[i]!=T[j])   /* 若当前字符与前缀字符不同 */
            nextval[i]=j;/* 则当前j为nextval在i位置上的值*/
        else            /* 若当前字符与前缀字符相同 */
            nextval[i]=nextval[j]/* 则将前缀字符的nextval值赋给nextval在i位置的值*/
     }else
        j = nextval[j];/* 若不相等则j值回溯*/
  }
}