Brute-Force算法

匹配失败，需要回退，平均时间复杂度O(mn)
最好时间复杂度O(m+n),每次匹配失败都在第一个字符就失败的情况下。

int BruteForce(char S[],char T[])   //不能用string类型的第0位置放长度
{
    int i=1,j=1;  //0号位置存储了字串的长度
    while(i<=S[0]&&j<=T[0])
    {
        if(S[i]==T[j])
        {
            i++;
            j++;
        }
        else
        {
            i=i-j+2;  //主串指针回退到这一轮比较的第一个元素的后一个。i-j表示主串回退到了上一次匹配的前一个，所以要再向后移两位
            j=1;  //模式串指针回退到第一个元素
        }
    }
    if(j>T[0])   //j大于自身长度时匹配成功
        return (i-T[0]);   //此时的i和j都已经移动了了模式串最后一个元素的后一个位置
    else
        return -1;
}
}

KMP算法

（字符串存储规则：0号位置放长度，从1号开始才放字符）

基本思路：主串指针永远不回退，模式串每次可以整体后移多位，使得原本最大公共后缀的位置，由原本最大公共前缀来代替。具体每次后移多少，只与模式串本身有关。因此可以提前计算好next数组，根据当前主串的坏字符，就能立刻知道模式串后移多少位了
匹配失败时，子串后移位数：当前匹配上的长度-前后最长公共子串长度，就是后移位数，但是不需要我们考虑，因为模式串指针j前移相当于做了这件事。
匹配失败时，子串指针j的回退位置：对于next数组，next[1]永远为0， next[2]永远为1。对于第j位字符（匹配失败的坏字符）前共j-1位字符串中，前后最大公共子串长度+1，（为什么要+1，因为原来尾部的公共子串和头部的是一样的，不需要再次匹配，所以j回退到头部的公共子串后面一个位置开始下一轮匹配）
公共前后缀短，是好事，因为模式串可以后移非常多位置
需要找到前后缀最长的匹配，如果不是最长匹配，会导致模式串往后移动过多，错过正确匹配

计算next数组

void get_next(char T[],int next[])  //模式串自己和自己比较计算
{
    int i=1;
    int j=0;
    next[1]=0; //非常巧妙，第一个元素的next值是0;
    //abaabcac
    while(i<T[0])
    {
        if(j==0||T[i]==T[j])  //j==0,表示模式串回退到了开头
        {
            i++;
            j++;
            next[i]=j;   //记录出现重复的位置
        }
        else
            j=next[j];    //当前元素不相同，找新位置比较
    }
}

KMP主体

int KMP(char S[],char T[],int next[],int pos)
{
    int i=pos; //主串的起始位置
    int j=1;
    while(i<=S[0]&&j<=T[0])
    {
        if(j==0||S[i]==T[j])   //j==0是为了对应next[1]==0这个条件，只要看后面，匹配上一位，往后走
        {
            i++;
            j++;
        }
        else
        {
            j=next[j];  //匹配失败，j回退
        }
    }

    if(j>T[0])

        return i-T[0];
    else
        return -1;
}

完整代码

#include<bits/stdc++.h>
using namespace std;

int BruteForce(char S[],char T[])   //不能用string类型的第0位置放长度
{
    int i=1,j=1;  //0号位置存储了字串的长度
    while(i<=S[0]&&j<=T[0])
    {
        if(S[i]==T[j])
        {
            i++;
            j++;
        }
        else
        {
            i=i-j+2;  //主串指针回退到这一轮比较的第一个元素的后一个。i-j表示主串回退到了上一次匹配的前一个，所以要再向后移两位
            j=1;  //模式串指针回退到第一个元素
        }
    }
    if(j>T[0])   //j大于自身长度时匹配成功
        return (i-T[0]);   //此时的i和j都已经移动了了模式串最后一个元素的后一个位置
    else
        return -1;
}


void get_next(char T[],int next[])  //模式串自己和自己比较计算
{
    int i=1;
    int j=0;
    next[1]=0; //非常巧妙，第一个元素的next值是0;
    //abaabcac
    while(i<T[0])
    {
        if(j==0||T[i]==T[j])  //j==0,表示模式串回退到了开头
        {
            i++;
            j++;
            next[i]=j;   //记录出现重复的位置
        }
        else
            j=next[j];    //当前元素不相同，找新位置比较
    }
}


int KMP(char S[],char T[],int next[],int pos)
{
    int i=pos; //主串的起始位置
    int j=1;
    while(i<=S[0]&&j<=T[0])
    {
        if(j==0||S[i]==T[j])   //j==0是为了对应next[1]==0这个条件，只要看后面，匹配上一位，往后走
        {
            i++;
            j++;
        }
        else
        {
            j=next[j];  //匹配失败，j回退
        }
    }

    if(j>T[0])

        return i-T[0];
    else
        return -1;
}

int main()
{
    char S[256];  //主串
    char T[10];    //模式串
    int next[10]= {0};
    int pos1,pos2;
    S[0]=strlen("abcabaaabaabcacdf");
    strcpy(S+1,"abcabaaabaabcacdf");  //把字符串拷贝到S[1]开始的空间,存储的就是长度本身，而非对应的asc码值
    T[0]=strlen("abaabcac");
    strcpy(T+1,"abaabcac");

    //暴力匹配
    pos1=BruteForce(S,T);
    cout<<pos1<<endl;

    //KMP
    /*手算next数组结果
    next[1]=0;
    next[2]=1;
    next[3]=1;
    next[4]=2;

    next[5]=2;
    next[6]=3;
    next[7]=1;
    next[8]=2;
    */

    get_next(T,next);
    pos2=KMP(S,T,next,1);
    cout<<pos2<<endl;

    for(int i=1; i<=8; i++)
        cout<<next[i]<<" ";

    return 0;
}