BF算法与KMP算法

BF算法

两个字符串 str sub

算法基本思想：
初始 i=0,j=0
1、当str[i]==sub[j]时i++,j++;
2、当str[i]!=sub[j]时，i=i-j+1,j=0;
3、当j>=strlen(str)或者i>=strlen(sub)结束

BF 算法的时间复杂度是：O(mn)
m 代表主串的长度， n 代表子串的长度。

代码实现：

int BF(const char *str, const char *sub, int pos)
{
    int lenstr = strlen(str);
    int lensub = strlen(sub);

    if (pos < 0 || pos>lenstr)
    {
        return -1;
    }

    int i = pos;
    int j = 0;

    while (i < lenstr&&j < lensub)
    {
        if (str[i] == sub[j])
        {
            i++;
            j++;
        }
        else
        {
            i = i - j + 1;
            j = 0;
        }
    }

    if (j >= lensub)
    {
        return i - j;
    }
    return -1;
}

KMP算法

KMP 算法更为高效

时间复杂度为 O(m+n)
m 代表主串的长度， n 代表子串的长度。

KMP 和 BF 唯一不一样的地方在：主串的 i 并不会回退， 并且 j 也不会移动到 0 号位置。

那j该如何退呢？

当 i 和 j 走到如下图位置

j 不需要回退到0，而是回退到上一个‘c‘的位置即可，假设每次回退为“K”位置。

我们要在确定sub中匹配到那一位不同时回退到对应的k位置，把所有的k都保存在next[strlen(sub)]数组中。

那如何确定每次回退到哪呢？
如上图i=j=5时，str[i]!=sub[j]，（用P0表示str[0]的字符,用S0表示sub[0]的字符）所以可以保证
P0P1P2P3P4=S0S1S2S3S4
这是观察可得应把j回退到S2即可，由于S0S1==P3P4==S3S4
同理假设str[i]!=sub[j]
得
P0P1P2,,,,,Pi ==S0S1S2,,,,,Sj
回退到k
存在S0,,,Sk-1 == Pi-k,,,Pi-1==Sj-k,,,,,Sj-1
第j位不同时，回退到k位置
so， next[j] = k ————条件1
由于当0号下标不同时，我们就会让j回退到当前位置，
但是默认next[0]=-1———条件2
由于当1号下标不同时，我们就会让j回退到0号位置，
so,next[1]=0———条件3
我们要根据已知的三个条件求 next[2] next[3],,,,,,,直到求出所有的next数组

由于Sj 与 Sk只存在两种关系 1、Sj = Sk 2、Sj != Sk
根据这两种关系我们做出两种假设

假设1、Sj = Sk
这时
S0,,,Sk-1 == Pi-k,,,Pi-1==Sj-k,,,,,Sj-1 【1】就可以拓展为
S0,,,Sk-1Sk ==Sj-k,,,,,Sj-1Sj 【2】

由于在【1】==>next[j] = k
so, 【2】==>next[j+1]=k+1

假设2、Sj != Sk ，如下图S2！=S5

这时由多次观察总结得
S5本来按Sj==Sk，应该回退到2位置但是很明显，S2!=S5,这时让k继续回退到2的k值====>k=next[k]

如此，就能求得所有next数组的值

每次遇到不同，让j回退到next[j]

代码实现

void GetNext(char *sub,int *next)
{
    int lensub = strlen(sub);
    next[0] = -1;
    next[1] = 0;
    int i = 2;//第二项
    int k = 0;
    while (i < lensub)
    {
        if ((k == -1) || sub[k] == sub[i -1])
        {
            next[i] = k + 1;
            i++;
            k++;
        }
        else
        {
            k = next[k];
        }
    }
}

int KMP(char *str, char *sub, int pos)
{
    int lenstr = strlen(str);
    int lensub = strlen(sub);

    if (pos < 0 || pos>lenstr)
    {
        return -1;
    }

    int i = pos;
    int j = 0;

    int *next = (int *)malloc(sizeof(int)*strlen(sub));
    assert(next != NULL);
    GetNext(sub, next);
    while (i < lenstr &&j < lensub)
    {
        if ((j == -1) || str[i] == sub[j])
        {
            i++;
            j++;
        }
        else
        {
            j = next[j];
        }
    }
    if (j >= lensub)
    {
        return i - j;
    }
    return -1;
}