相信我们都有在linux下查找文本内容的经历，比如当我们使用vim查找文本文件中的某个字或者某段话时，Linux很快做出反应并给出相应结果，特别方便快捷！
那么，我们有木有想过linux是如何在浩如烟海的文本中正确匹配到我们所需要的字符串呢？这就牵扯到了模式匹配算法！
1. 模式匹配
什么是模式匹配呢？
- 模式匹配，即子串P(模式串)在主串T(目标串)中的定位运算，也称串匹配
假设我们有两个字符串：T(Target, 目标串)和P(Pattern, 模式串)；在目标串T中查找模式串T的定位过程，称为模式匹配.
模式匹配有两种结果：
- 目标串中找到模式为T的子串，返回P在T中的起始位置下标值；
- 未成功匹配，返回-1
通常模式匹配的算法有很多，比如BF、KMP、BM、RK、SUNDAY等等，它们各有千秋，我们此处重点讲解BF和KMP算法(因为比较常用)
2. BF算法
BF，即Brute-Force算法，也称为朴素匹配算法或蛮力算法，效率较低！
1). 算法思想
基本思想：
- 将目标串T第一个字符与模式串P的第一个字符比较；
- 若相等，则比较T和P的第二个字符
- 若不等，则比较T的下一个字符与P的第一个字符
- 重复步骤以上步骤，直到匹配成功或者目标串T结束
流程图如下：
例如：
设 T=‘ababcabcacbab‘, P=‘abcac‘, 匹配流程
- Step 1: 主串T与子串P做顺序比较，当比较到位置2时，主串T[2]=‘a‘与子串P[2]=‘c‘不等(蓝色阴影表示)，记录各自的结束位置，并进入Step 2
- Step 2: 主串T后移一位，主串T与子串P再从头开始比较，比较如Step 1
- Step 3: 每次比较，子串都从0开始，主串的开始位置与上次的结束位置存在一定的关系；在某些时候需要“回溯”(上次比较结束的位置要向前移动)；如Step 1的结束位置为2，Step 2的开始位置为1；Stp3的结束位置为6，Step 4的开始位置为3等；
- Step 4: 主串T的索引值i 与 子串P的索引值j的关系为：i=i-j+1
2). 代码实现
/*-----------------------------------------------------------------------------
* Function: BF - Does the P can be match in T
* Input: Pattern string P, Target string T
* Output: If matched: the index of first matched character
* else: -1
-----------------------------------------------------------------------------*/
int BF(const string &T, const string &P)
{
int j=0, i=0, ret=0;
while((j < P.length()) && (i<T.length()))
{
if(P[j] == T[i]) //字符串相等则继续
{
i++;
j++; //目标串和子串进行下一个字符的匹配
}
else
{
i = i - j + 1;
j = 0; //如果匹配不成功，则从目标字符串的下一个位置开始从新匹配
}
}
if(i < T.length()) //若匹配成功，返回匹配的第一个字符的下标值
ret = i - P.length() ;
else
ret = -1;
return ret;
}
3). 效率分析
效率分析主要是分析时间复杂度和空间复杂度. 而本例的空间复杂度较低，暂时不做考虑，我们来看看时间复杂度。
分析时间复杂度通常是分析最坏情况，对于BF算法来说，最坏情况举例如下：
T="ggggggggk", P="ggk"
由上图可知，第i次匹配，前面第i-1次匹配，每次都需要比较m次(m为模式串P的长度)，因此为(i-1)m次；第i次匹配成功也需要m次比较，因此总共需要比较mi次。
对于长度为n的主串T，i=n-m+1,每次匹配成功的概率为Pi，且概率相等；则在最坏情况下，匹配成功的概率Cmax可表示为：
一般情况下 n>>m,因此，BF的时间复杂度为 O(m*n)
3. KMP算法
BF算法每次都需要回溯，导致时间复杂度较大，那么有没有一种效率更高的模式匹配算法呢？
答案是肯定的，那就是KMP算法。
1). 名词解释
在进行算法讲解之前，必须要明确以下几个名词，否则无法理解此算法
- 目标串 T: 即大量的等待被匹配的字符串
- 模式串 P：即我们需要查找的字符串
- 字符串前缀：字符串的任意首部(不包括最后一个字符)；如"abcd"的前缀为"a","ab","abc",但不包括"abcd"
- 字符串后缀：字符串的任意尾部(不包括第一个字符)；如"abcd"的后缀为"d","cd","bcd",但不包括"abcd"
- 字符串前后缀相等位数k：即前缀与后缀的最长匹配位数，
2). 算法思想
KMP算法的核心思想是：部分匹配，即不再把主串的位置移动到已经比较过的位置(不再回溯)，而是根据上一次比较结果继续后移。
概念相当抽象，那么我们以例子来解释：
- Step 1: 匹配到索引值index=2时，匹配失败
- Step 2: 匹配的开始位置为index=2(没有回溯到1), 原因如下：
Step 1 比较后，已知T[1]=‘b‘, S[0]=‘a‘，理论上已经比较过了，所以无需回溯再次比较
Step 2 一直进行匹配，直到T[6]时刻失配.
- Step 3: T的位置不进行回溯，还是保持在T[6]开始(KMP算法规定：目标串T不回溯，上一次的结束位置即为下一次的开始位置)；
P的索引值从1开始而非0，原因如下：
在Step 2 中，T[5]=‘a‘已经比较过，我们已知，且与P[3]相等；因为P[0]==P[3]，所以无需比较P[0]与T[5]，因为Step 2 理论上已经进行了比较(其实就是看子串P Step2结束位置P[4]之前的P[0-3]的字符串前后缀相等位数k，使得P[k]与上次主串的结束位置T[6]对齐)
由以上分析可知，KMP算法过程中关键点就是求： 子串P结束位置前的前后缀相等位数k。
下图是模式串P="abcabca"的前后缀关系分析(包括前后缀字符串相等位数k)
由上图我们可以给出，T串每一个字符做结束位置时，下一次的开始位置的值；
- j 为T的本次匹配结束位置(失配位置);
- next[j] 为下次匹配模式串P的开始位置
PS: next[j]就是前后缀字符串相等位数k
根据上面的讨论，我们可以得出next[j]的运算公式：
其中，-1 是一个标记，标识下一次的开始位置目标串为
,模式串P为
如果以上你没有明白，不要紧的，只需要记住next[j]的函数就可以，其它一切都是根据它来的！
3). 代码实现
/*-----------------------------------------------------------------------------
* Function: KMP- Does the P can be match in T
* Input: Pattern string P, array next
* Output: If matched: the index of first matched character
* else: -1
-----------------------------------------------------------------------------*/
void getNext(const string &P, int next[])
{
int j=0; //模式串P的下标值/索引值
int k=-1; //模式串P的前缀和后缀串相等的位数
next[0]=-1; //置初值
while(j < P.length())
{
if((k == -1) || (P[j] == P[k])) //从模式串P的开始位置处理 或 顺序比较主串和子串
{
j++;
k++;
next[j] = k;
}
else //设置重新比较位置：j串不变，k串从next[k]位置开始
k = next[k];
}
}
/*-----------------------------------------------------------------------------
* Function: KMP- Does the P can be match in T
* Input: Pattern string P, Target string T
* Output: If matched: the index of first matched character
* else: -1
-----------------------------------------------------------------------------*/
int KMP(const string &T, const string &P)
{
int next[MaxSize]={0};
int i=0; //目标串T的下标值/索引值
int j=0; //模式串P的下标值/索引值
int ret=0;
getNext(P, next); //获取模式串P的next数组
int PLen = P.length();
int TLen = T.length();
while((i < T.length()) && (j < PLen)) //奇怪，此处我用 j<P.length()就不行，待解决
{
if((j==-1) || (P[j] == T[i])) //j=-1表示首次比较
{
i++;
j++;
}
else
{
j = next[j];
}
}
if(j >= P.length())
ret = i-P.length();
else
ret = -1;
return ret;
}
4). 效率分析
由于KMP算法不回溯，比较是顺序进行的，因此最坏情况下的KMP时间复杂度为 O(m+n).
其中，m为模式串P的字符串长度，n为目标串T的字符串长度.
原文地址：https://www.cnblogs.com/Jimmy1988/p/8407166.html