BF算法与KMP算法

      BF(Brute Force)算法是普通的模式匹配算法，BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配，若相等，则继续比较S的第二个字符和 T的第二个字符；若不相等，则比较S的第二个字符和T的第一个字符，依次比较下去，直到得出最后的匹配结果。

BF算法实现：

int BF(char S[],char T[],int pos)
{//c从第pos位开始搜索匹配
    int i=pos,j=0;
    while(S[i+j]!='\0'&&T[j]!='\0')
    {
        if(S[i+j]==T[j])
            j++;
        else
        {
            i++;
            j=0;
        }
    }
    if(T[j]=='\0')
        return i+1;
    else
        return -1;
}

BF算法比较直接，是一种蛮力算法，该算法最坏情况下要进行M*(N-M+1)次比较，时间复杂度为O(M*N)，下面来看一个效率非常高的字符串匹配算法，即KMP算法。
KMP算法完成的任务是：给定两个字符串S和T，长度分别为n和m，判断f是否在S中出现，如果出现则返回出现的位置。常规方法是遍历a的每一个位置，然后从该位置开始和b进行匹配，但是这种方法的复杂度是O(nm)。kmp算法通过一个O(m)的预处理，使匹配的复杂度降为O(n+m)。

KMP算法思想:

优化的地方：如果我们知道模式中a和后面的是不相等的，那么第一次比较后，发现后面的的4个字符均对应相等，可见a下次匹配的位置可以直接定位到f了。说明主串对应位置i的回溯是不必要的。这是kmp最基本最关键的思想和目标。

由于abc 与后面的abc相等，可以直接得到红色的部分。而且根据前一次比较的结果，abc就不需要比较了，现在只需从f-a处开始比较即可。说明主串对应位置i的回溯是不必要的。要变化的是模式串中j的位置（j不一定是从1开始的，比如第二个例子）j的变化取决于模式串的前后缀的相似度，例2中abc和abc（靠近x的），前缀为abc，j=4开始执行。

 

下面我们来看看Next()数组：

定义：

（1）next[0]= -1 意义：任何串的第一个字符的模式值规定为-1。

（2）next[j]= -1   意义：模式串T中下标为j的字符，如果与首字符相同，且j的前面的1—k个字符与开头的1—k个字符不等（或者相等但T[k]==T[j]）（1≤k<j< span="">）。如：T=”abCabCad” 则 next[6]=-1，因T[3]=T[6]

（3）next[j]=k    意义：模式串T中下标为j的字符，如果j的前面k个字符与开头的k个字符相等，且T[j] != T[k] （1≤k<j< span="">）。即T[0]T[1]T[2]。。。T[k-1]==T[j-k]T[j-k+1]T[j-k+2]…T[j-1]

且T[j] != T[k].（1≤k<j< span="">）;

(4) next[j]=0   意义：除（1）（2）（3）的其他情况。

 

意义：

 next 函数值究竟是什么含义，前面说过一些，这里总结。

设在字符串S中查找模式串T，若S[m]!=T[n],那么，取T[n]的模式函数值next[n],

1.       next[n]= -1 表示S[m]和T[0]间接比较过了，不相等，下一次比较 S[m+1] 和T[0]

2.       next[n]=0 表示比较过程中产生了不相等，下一次比较 S[m] 和T[0]。

3.       next[n]= k >0 但k<n, <="" span="">表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了，下一次比较S[m]和T[k]相等吗？

4.       其他值，不可能。

 

Next()数组求解的实现：

void getNext(const char* pattern,int next[])
{
       next[0]=   -1;
       int k=-1,j=0;
       while(pattern[j] != '\0')
       {
              if(k!= -1 && pattern[k]!= pattern[j] )
                     k=next[k];
              ++j;++k;
              if(pattern[k]== pattern[j])
                     next[j]=next[k];
              else
                     next[j]=k;
       }
}

 

 

Next()数组求出后，就可以进行字符串匹配了

int KMP(char *s,char* t)
{
       if( !s||!t|| t[0]=='\0' || s[0]=='\0' )
              return -1;//空指针或空串，返回-1。
       int len=0;
       const char * c=t;
       while(*c++!='\0')
       {
              ++len;
       }
       int *next=new int[len+1];
       getNext(t,next);

       int index=0,i=0,j=0;
       while(s[i]!='\0' && t[j]!='\0' )
       {
              if(s[i]== t[j])
              {
                     ++i;
                     ++j;
              }
              else
              {
                     index += j-next[j];
                     if(next[j]!=-1)
                            j=next[j];
                     else
                     {
                            j=0;
                            ++i;
                     }
              }
       }
       delete []next;
       if(t[j]=='\0')
              return index;
       else
              return -1;
}

写到这，KMP算法介绍的也差不多了，关于KMP算法优化，待续。。。。