字符串------子串匹配

题目描述：
设有文本串S和模式串P，现在要P是否为S的一个子串，若是，则返回P在S中开始的位置，若不是，返回-1．
分析：
一般来说，我们可以使用朴素匹配的方法，逐个匹配。假设文本串长为n，模式串长为m，则朴素匹配的时间复杂度为O((n-m+1)*m).

//朴素匹配
int Search(char *S, char *P)
{
    if(S == NULL || P == NULL)
        return -1;
    int sLen = strlen(S);
    int pLen = strlen(P);
    int i = 0, j = 0;

    while(i < sLen && j < pLen)
    {
        if(S[i] == P[j])
        {
            ++i;
            ++j;
        }
        else
        {
            i = i - j + 1; //退回上次匹配中S开始处的下一个位置
            j = 0;
        }
    }
    if(j == pLen)
        return i - j;
    else
        return -1;
}

更高效的方法——KMP算法
其过程是：　设　文本串S匹配到了i位置，模式串匹配到了j位置则有
1. 若 j = -1 或当前字符匹配成功，则 j++ 且 i++ .
2. 若 j != -1 且当前字符匹配失败，则 i 不变，j = next[j] .
(注: next[j] = k 表示位置 j 之前的串中有最大长度为 k 的相同前缀串和后缀串. 字符串下标从 0 开始)

int KMPSearch(char *S, char *P)
{
    int i = 0, j = 0;
    int sLen = strlen(S);
    int pLen = strlen(P);

    while(i < sLen && j < pLen)
    {
        if(j == -1 || S[i] == p[j])
        {
            ++i;
            ++j;
        }
        else
        {//若匹配失败，则 i 无需回退，只需要使得 j = next[j] 即可.
            j = next[j]   //相当于把模式串向后移动 j - next[j]位
        } 
    }
    if(j == pLen)
        return i - pLen;
    else
        return -1;
}

//计算next[]数组
//步骤:  1.寻找从字符串头部到当前字符为止的这段字符串内的最大相同前缀和后缀长度.
//步骤:  2.将计算好的值整体右移一位，并将起始位置的初值置为 -1 . 
//例子:
//                    a  b  c  c  a  b  c 
//最大相同前后、缀长度   0  0  0  0  1  2  3
//next              -1  0  0  0  0  1  2

void GetNext(char *P, int next[])
{
    int pLen = strlen(P);
    next[0] = -1;
    int k = -1, j = 0;
    while(j < pLen - 1)
    {
        if(k == -1 || P[j] == P[K])
        {
            ++k;
            ++j;
            next[j] = k;
        }
        else
        {
            k = next[k];
        }
    }
} 

//还有改进，待续......