LeetCode Implement strStr()(朴素的字符串匹配，RK算法，KMP算法)

这次来个大整合，因为正好处理到经典的字符串匹配问题

那么也是用c语言实现，现在开始吧

Implement strStr().

Returns the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

简单的问题描述，字符串needle是否尾haystack的子字符串，是的返回索引，没有返回-1；

Plan A暴力AC（朴素的字符串匹配。-。-）没必要解释了毕竟naive算法

int strStr(char* haystack, char* needle) 
{
    if(*needle=='\0')
    {
        return 0;
    }
    int flag=0;
    int pos=-1;
    for(int i=0;*(haystack+i)!='\0';i++)
    {
        for(int j=0;*(needle+j)!='\0';j++)
        {
           if(*(haystack+i+j)!='\0')
           {
               if(*(haystack+i+j)==*(needle+j))
               {
                   flag=1;
               }
               else
               {
                   flag=0;
                   break;
               }
           }
           else
           {
               flag=0;
               break;
           }
        }
        if(flag==1)
        {
            pos=i;
            break;
        }
    }
    return pos;
    exit(0);
}

PlanB（RK算法）

它的思路确实很新颖的，想法值得我们学习

那么先简单分析一下算法，被检测串将其转换成hash（其实就是把字符转换成数字）

算法导论里说这个要用霍纳准则，ok，这bi装的beautiful，举个例子假如我们只有10个数字的字符串

检测“0123456789”中有没有“567”先把“567”转换成(（5*10+6）*10+7）然后我们要在从头开始检测对吧，012=（0*10+1）*10+2，ok他和567的转换不同，不检测

接下来要检测123怎么办，先012把高位减去变成12再乘10+3就可以了

那么我们现在要字符串检测，那么就有256个字符，“Geeks is funny”检测“funny”

先把funny转换了我们都知道字符也是数字，所以(((‘f’*256+'u')*256+'n')*256+'n')*256+'y'==(肯定是个值我没算，有兴趣可以算下）

那么我们第一个窗口得转换((('G'*256+'e')*256+'e')*256+'k')*256+'s')==（我也没算但是只要不傻都知道这两个不相等），所以这不是目标串

（即使相等也要朴素的检测）

代码怎么实现这样的计算呢？

 for(int i=0;i<m;i++)

    {
        p=(p*256+needle[i])%101;
        t=(t*256+haystack[i])%101;
    }

现在目标串的长度为m，p为要检测的目标，t这里的计算算的正好是我们前面说的第一个窗口，但是大家都发现哎我们模了个101干什么的？

当m足够大的时候可能会溢出，这个时候我们模上一个质数（随便摸，模什么质数都行保证别溢出）你就不模质数都可以，调皮OK，推荐模一个质数可以减少重复的次数

（因为相等我们都是要朴素的匹配一次，所以你调皮可以，我很喜欢）

那么这里还有一个移位的问题没有交代

先计算256的m-1次方（匹配穿的长度减1）

int h=1;

for(int I=0;i<m-1;i++)

{

h=(h*256)%101;

}

ok我们算出来以后呢

带到这个里面更新

  t=(256*(t-h*haystack[i])+haystack[i+m])%10;

自己算一算别光看如果觉得分开看不明白那么我就po上代码

int strStr(char* haystack, char* needle) 
{
    if(*needle=='\0')
    {
        return 0;
    }
    int h=1;
    int p=0;
    int t=0;
    int m=strlen(needle);
    int n=strlen(haystack);
    for(int i=0;i<m-1;i++)
    {
        h=(h*256)%101;
    }
    for(int i=0;i<m;i++)
    {
        p=(p*256+needle[i])%101;
        t=(t*256+haystack[i])%101;
    }
    int j=0;
    for(int i=0;i<=n-m;i++)
    {
        if(p==t)
        {
            for(j=0;j<m;j++)
            {
                if(needle[j]==haystack[i+j])
                {
                }
                else
                {
                    break;
                }
                if(j==m-1)
                {
                    return i;
                }
            }
        }
        if(i<n-m)
        {
            t=((t-haystack[i]*h)*256+haystack[i+m])%101;
            if(t<0)
            {
                t=t+101;
            }
        }
    }
    return -1;
}

最后来说一说kmp算法，这个算法网上资料很多，我这学习这个算法可以说一波三折，先小甲鱼的KMP算法的讲解（说的不错-。-，然而我还是没明白），然后各种网上资料

百度，最后在严蔚敏老师的算法和数据结构中弄明白这个问题，想用博客说清楚有点难度，这里安利一波严蔚敏老师的数据结构吧，耐心点（老师的声音让人迷之发困）

直接po上代码吧，本来还想分析一下各个算法的优劣但是图传不上去，那么这次的博客就简单点吧

int strStr(char* haystack, char* needle)
{
    if(*needle=='\0')
    {
        return 0;
    }
    int LengthOfPartten=strlen(needle);
    int *next=(int *)malloc(sizeof(int)*LengthOfPartten);
    next[0]=-1;
    int j=-1;
    int i=0;
    int LengthOfText=strlen(haystack);
    while(i<LengthOfPartten-1)
    {
        if(j==-1||needle[i]==needle[j])
        {
            i++;
            j++;
            next[i]=j;
        }
        else
        {
            j=next[j];
        }
    }
    for(int i=0;i<LengthOfPartten;i++)
    {
        printf("%d\n",next[i]);
    }
    i=0;
    j=0;
    while(i<LengthOfText)
    {
        if(haystack[i]==needle[j])
        {
            if(j==LengthOfPartten-1)
            {
                return i-j;
                break;
            }
            i++;
            j++;
        }
        else
        {
            if(j==0)
            {
                i++;
            }
            else
            {
                j=next[j];
            }
        }
    }
    return -1;
}