字符串模式匹配

字符串模式匹配，即字串的定位操作。就是判断主串S中是否存在给定的子串，如果存在，那么返回子串在S中的位置，否则返回0。

实现这种操作有两种算法：

- 朴素的模式匹配算法

S长度为n，T长度为m。

思路
对于主串的每个字符，做长度为strlen(T) 的循环，判断是否与子串匹配。
最好的情况就是一开始就匹配成功，时间复杂度O(1)；
最坏的情况就是每次匹配失败都是在T的最后一个元素，复杂度O(n*m);
平均情况复杂度O(n + m)。

/*下标从0开始，查找从第pos个位置开始*/
#include <stdio.h>
#include <string.h>

int Index(char S[], char T[], int pos)
{
    int i = pos;       //i记录S当前下标
    int j = 0;          //j记录T当前下标
    while (i < strlen(S) && j < strlen(T))
    {
        if (S[i] == T[j])
        {
            i++;
            j++;
        }
        else
        {
            i = i - j + 1;   //i退回到上次匹配首字母的下一位
            j = 0;          //j退回到T开始
        }
    }
    if (j == strlen(T))
        return i - j;
    else
        return -1;
}

int main(int argc, char** argv)
{
    char s[] = "Hello World!";
    char t[] = "World";

    printf("%d\n",Index(s, t, 0));

    return 0;
}

- KMP算法

众所周知，计算机处理的都是二进制数据，那么所有的0，1串如果都采用朴素的模式匹配，实在低效~
所以大佬们觉得遍历这种做法实在low，D.E. Knuth, J.H. Morris, V.R. Pratt就提出了KMP算法来优化传统的匹配算法。

思路
KMP主要分两步：

1. 进行T的自匹配
   这一步关键在于得到Next数组，从T的第一位开始对自身匹配，在某一位置能匹配的最长长度即是当前位置Next值。
   而Next数组则是由PMT数组后移一位得到，将Next[0] = -1。
   那么PMT又是什么呢？
   PMT(Partial Match Table)—–部分匹配表。

PMT中的值是字符串的前缀集合与后缀集合的交集中最长元素的长度。

1. S与T的匹配
   这步的匹配和朴素匹配没有太大差异，只是S串的指针不用回溯，而将j回溯到Next[j]位置。

#include <stdio.h>
#include <string.h>

/*计算next数组*/
void next_compute(char T[], int* next)
{
    int i = 0, j = -1;
    next[0] = -1;
    while (i < strlen(T))
    {
        if (-1 == j || T[i] == T[j]) //自匹配
        {
            i++;
            j++;
            next[i] = j;
        }
        else               //字符不同，j值回溯
        {
            j = next[j];
        }
    }
}

int KMP(char S[], char T[], int pos)
{
    int next[255];
    int i = pos, j = 0;
    int Slen, Tlen;

    next_compute(T, next);
    Slen = strlen(S);
    Tlen = strlen(T);

/*此处while循环条件不能用strlen，strlen()不能与负数比较大小*/
    while (i < Slen && j < Tlen)
    {
        if (-1 == j || S[i] == T[j])
        {
            i++;
            j++;
        }
        else
        {
            j = next[j];            //j回退到合适位置
        }
    }

    if (j == strlen(T))
        return i - j;
    else
        return -1;
}

int main(int argc, char** argv)
{
    char s[] = "hello world!";
    char t[] = "world";

    printf("%d\n",KMP(s, t, 0));

    return 0;
}

- 改进KMP算法

主要改进了Next数组。

/*计算next数组*/
void next_compute(char T[], int* next)
{
    int i = 0, j = -1;
    next[0] = -1;
    while (i < strlen(T))
    {
        if (-1 == j || T[i] == T[j]) //自匹配
        {
            i++;
            j++;
            if (T[i] != T[j])
                next[i] = j;
            else
                next[i] = next[j];
        }
        else               //字符不同，j值回溯
        {
            j = next[j];
        }
    }
}

转载于:https://www.cnblogs.com/EIMadrigal/p/9248215.html