Table of Contents

模式搜索的KMP算法

如何更好地理解和掌握 KMP 算法?

模式搜索的KMP算法

https://www.geeksforgeeks.org/kmp-algorithm-for-pattern-searching/

给定文本txt [0..n-1]和模式pat [0..m-1]，编写一个函数search（char pat []，char txt []），将所有出现的pat []都打印在txt中[]。您可以假设n> m。

例子：

输入：txt [] =“这是一个测试文本”pat [] =“ TEST”
输出：在索引10处找到的模式输入：txt [] =“ AABAACAADAABAABA”pat [] =“ AABA”
输出：在索引0找到的模式在索引9处找到的模式在索引12处找到的模式

模式搜索是计算机科学中的一个重要问题。当我们在记事本/单词文件或浏览器或数据库中搜索字符串时，将使用模式搜索算法来显示搜索结果。

我们在讨论天真模式搜索算法以前的帖子。朴素算法的最坏情况复杂度是O（m（n-m + 1））。在最坏的情况下，KMP算法的时间复杂度为O（n）。

KMP（克努特莫里斯普拉特）模式搜索
的朴素模式搜索算法并不在我们看到许多匹配字符，随后是不匹配的字符的情况下很好地工作。以下是一些示例。

   txt [] =“ AAAAAAAAAAAAAAAAAB”pat [] =“ AAAAB”txt [] =“ ABABABCABABABCABABABC”pat [] =“ ABABAC”（这不是最坏的情况，但对于Naive来说是坏情况）

KMP匹配算法使用模式的退化属性（具有相同子模式的模式在模式中出现多次），并将最坏情况下的复杂度提高到O（n）。KMP算法背后的基本思想是：每当检测到不匹配时（在某些匹配之后），我们就已经知道下一个窗口文本中的某些字符。我们利用这些信息来避免匹配我们知道会匹配的字符。让我们考虑下面的例子来理解这一点。

配套概述
txt =“ AAAAABAAABA”
pat =“ AAAA”我们将txt的第一个窗口与pat
txt =“ AAAA ABAAABA”进行比较
pat =“ AAAA ” [初始位置]
我们找到一个匹配项。这与朴素字符串匹配相同。在下一步中，我们将txt和pat的下一个窗口进行比较。
txt =“ AAAA A BAAABA”
pat =“ AAA A ” [模式移动了一个位置]
这是KMP在Naive上进行优化的地方。在这个
第二个窗口，我们只比较模式的第四个A
用当前文本窗口的第四个字符来决定
当前窗口是否匹配。既然我们知道
无论如何，前三个字符都会匹配，我们跳过了
匹配前三个字符。 需要预处理吗？
上述解释引起了一个重要的问题，
如何知道要跳过多少个字符。要知道这个
我们预处理模式并准备一个整数数组
lps []告诉我们要跳过的字符数。

预处理概述：

注意： lps [i]也可以定义为最长前缀，这也是适当的后缀。我们需要在一个地方正确使用以确保不考虑整个子字符串。

lps []构造示例：
对于模式“ AAAA”，
lps []为[0，1，2，3]对于模式“ ABCDE”，
lps []为[0，0，0，0，0]对于模式“ AABAACAABAA”，
lps []为[0，1，0，1，2，0，1，2，3，4，5]对于模式“ AAACAAAAAC”，
lps []为[0，1，2，0，1，2，3，3，3，4] 对于模式“ AAABAAA”，
lps []为[0，1，2，0，1，2，3]

搜索算法：
与朴素算法不同，在朴素算法中，我们将模式滑动一个并比较每个班次的所有字符，我们使用lps []中的值来确定要匹配的下一个字符。想法是不匹配我们知道会匹配的字符。

如何使用lps []决定下一个位置（或知道要跳过的字符数）？

txt [] =“ AAAA ABAAABA”
pat [] =“ AAAA ”
lps [] = {0，1，2，3} i = 0，j = 0
txt [] =“ A AAA ABAAABA”
pat [] =“ A AAA ”
txt [i]和pat [j]匹配，是否i ++，j ++i = 1，j = 1
txt [] =“ A A AA ABAAABA”
pat [] =“ A A AA A ”
txt [i]和pat [j]匹配，是否i ++，j ++i = 2，j = 2
txt [] =“ AA A A ABAAABA”
pat [] =“ AA A A ”
pat [i]和pat [j]匹配，是否i ++，j ++i = 3，j = 3
txt [] =“ AAA A ABAAABA”
pat [] =“ AAA A ”
txt [i]和pat [j]匹配，是否i ++，j ++i = 4，j = 4
由于j == M，找到打印图案并重置j，
j = lps [j-1] = lps [3] = 3这里不像朴素算法，我们不匹配前三个
此窗口的字符。lps [j-1]的值（如上）
步骤）给我们下一个要匹配的字符的索引。
i = 4，j = 3
txt [] =“ A AAA A BAAABA”
pat [] =“ AAA A ”
txt [i]和pat [j]匹配，是否i ++，j ++i = 5，j = 4
由于j == M，找到打印图案并重置j，
j = lps [j-1] = lps [3] = 3再次与朴素算法不同，我们不匹配前三个
此窗口的字符。lps [j-1]的值（如上）
步骤）给我们下一个要匹配的字符的索引。
i = 5，j = 3
txt [] =“ AA AAA B AAABA”
pat [] =“ AAA A ”
txt [i]和pat [j]不匹配且j> 0，仅更改j
j = lps [j-1] = lps [2] = 2i = 5，j = 2
txt [] =“ AAA AA B A AABA”
pat [] =“ AA A A ”
txt [i]和pat [j]不匹配且j> 0，仅更改j
j = lps [j-1] = lps [1] = 1 i = 5，j = 1
txt [] =“ AAAA A B AA ABA”
pat [] =“ A A AA A ”
txt [i]和pat [j]不匹配且j> 0，仅更改j
j = lps [j-1] = lps [0] = 0i = 5，j = 0
txt [] =“ AAAAA B AAA BA”
pat [] =“ A AAA ”
txt [i]和pat [j]不匹配且j为0，我们使用i ++。i = 6，j = 0
txt [] =“ AAAAAB A AABA ”
pat [] =“ A AAA ”
txt [i]和pat [j]匹配，i ++和j ++i = 7，j = 1
txt [] =“ AAAAAB A A AB A”
pat [] =“ A A AA A ”
txt [i]和pat [j]匹配，i ++和j ++我们继续这样...

KMP算法对pat []进行预处理，并构造一个大小为m（与模式大小相同）的辅助lps []，用于在匹配时跳过字符。
名称lps表示最长的适当前缀，该前缀也是后缀。。一个适当的前缀是前缀与整个字符串不容许。例如，“ ABC”的前缀是“”，“ A”，“ AB”和“ ABC”。适当的前缀为“”，“ A”和“ AB”。字符串的后缀是“”，“ C”，“ BC”和“ ABC”。
我们在子模式中搜索lps。更清楚地，我们集中于模式的子字符串，即前缀和后缀。
对于其中i = 0到m-1的每个子模式pat [0..i]，lps [i]存储最大匹配的适当前缀的长度，该长度也是子模式pat [0..i]的后缀。
```
   lps [i] = pat [0..i]的最长适当前缀 这也是pat [0..i]的后缀。 
```
- 我们开始将pat [j]与j = 0与当前文本窗口的字符进行比较。
- 我们保持匹配字符txt [i]和pat [j]，并保持i和j递增，而pat [j]和txt [i]保持匹配。
- 当我们看到不匹配时
  - 我们知道字符pat [0..j-1]与txt [ij…i-1]匹配（请注意j以0开头，只有在存在匹配项时才递增）。
  - 从上面的定义中我们还知道lps [j-1]是pat [0…j-1]的字符计数，它们都是正确的前缀和后缀。
  - 从以上两点可以得出结论，我们不需要将这些lps [j-1]字符与txt [ij…i-1]匹配，因为我们知道这些字符仍然可以匹配。让我们考虑上面的例子来理解这一点。

// C++ program for implementation of KMP pattern searching
// algorithm
#include <bits/stdc++.h> void computeLPSArray(char* pat, int M, int* lps); // Prints occurrences of txt[] in pat[]
void KMPSearch(char* pat, char* txt)
{ int M = strlen(pat); int N = strlen(txt); // create lps[] that will hold the longest prefix suffix // values for pattern int lps[M]; // Preprocess the pattern (calculate lps[] array) computeLPSArray(pat, M, lps); int i = 0; // index for txt[] int j = 0; // index for pat[] while (i < N) { if (pat[j] == txt[i]) { j++; i++; } if (j == M) { printf("Found pattern at index %d ", i - j); j = lps[j - 1]; } // mismatch after j matches else if (i < N && pat[j] != txt[i]) { // Do not match lps[0..lps[j-1]] characters, // they will match anyway if (j != 0) j = lps[j - 1]; elsei = i + 1; } }
} // Fills lps[] for given patttern pat[0..M-1]
void computeLPSArray(char* pat, int M, int* lps)
{ // length of the previous longest prefix suffix int len = 0; lps[0] = 0; // lps[0] is always 0 // the loop calculates lps[i] for i = 1 to M-1 int i = 1; while (i < M) { if (pat[i] == pat[len]) { len++; lps[i] = len; i++; } else // (pat[i] != pat[len]) { // This is tricky. Consider the example. // AAACAAAA and i = 7. The idea is similar // to search step. if (len != 0) { len = lps[len - 1]; // Also, note that we do not increment // i here } else // if (len == 0) { lps[i] = 0; i++; } } }
} // Driver program to test above function
int main()
{ char txt[] = "ABABDABACDABABCABAB"; char pat[] = "ABABCABAB"; KMPSearch(pat, txt); return 0;
}

输出：

找到索引10的模式

预处理算法：
在预处理部分，我们用lps []计算值。为此，我们跟踪上一个索引的最长前缀后缀值的长度（为此目的，我们使用len变量）。我们将lps [0]和len初始化为0。如果pat [len]和pat [i]匹配，我们将len加1并将增加的值分配给lps [i]。如果pat [i]和pat [len]不匹配且len不为0，则将len更新为lps [len-1]。有关详细信息，请参见下面的代码中的computeLPSArray（）。

预处理图解（或构建lps []）

pat [] =“ AAACAAAA ”len = 0，i = 0。
lps [0]始终为0，我们移动
到我= 1len = 0，i = 1。
由于pat [len]和pat [i]匹配，所以请执行len ++，
将其存储在lps [i]中并执行i ++。
len = 1，lps [1] = 1，i = 2len = 1，i = 2。
由于pat [len]和pat [i]匹配，所以请执行len ++，
将其存储在lps [i]中并执行i ++。
len = 2，lps [2] = 2，i = 3len = 2，i = 3。
由于pat [len]和pat [i]不匹配，并且len> 0，
设置len = lps [len-1] = lps [1] = 1len = 1，i = 3。
由于pat [len]和pat [i]不匹配且len> 0，
len = lps [len-1] = lps [0] = 0len = 0，i = 3。
由于pat [len]和pat [i]不匹配且len = 0，
设置lps [3] = 0且i = 4。
我们知道角色拍拍
len = 0，i = 4。
由于pat [len]和pat [i]匹配，所以请执行len ++，
将其存储在lps [i]中并执行i ++。
len = 1，lps [4] = 1，i = 5len = 1，i = 5。
由于pat [len]和pat [i]匹配，所以请执行len ++，
将其存储在lps [i]中并执行i ++。
len = 2，lps [5] = 2，i = 6len = 2，i = 6。
由于pat [len]和pat [i]匹配，所以请执行len ++，
将其存储在lps [i]中并执行i ++。
len = 3，lps [6] = 3，i = 7len = 3，i = 7。
由于pat [len]和pat [i]不匹配且len> 0，
设置len = lps [len-1] = lps [2] = 2len = 2，我= 7。
由于pat [len]和pat [i]匹配，所以请执行len ++，
将其存储在lps [i]中并执行i ++。
len = 3，lps [7] = 3，i = 8我们在构造整个lps []时就在这里停止。

如何更好地理解和掌握 KMP 算法?

https://www.zhihu.com/question/21923021

有些算法，适合从它产生的动机，如何设计与解决问题这样正向地去介绍。但KMP算法真的不适合这样去学。最好的办法是先搞清楚它所用的数据结构是什么，再搞清楚怎么用，最后为什么的问题就会有恍然大悟的感觉。我试着从这个思路再介绍一下。大家只需要记住一点，PMT是什么东西。然后自己临时推这个算法也是能推出来的，完全不需要死记硬背。

KMP( Knuth-Morris-Pratt )算法的核心，是一个被称为部分匹配表(Partial Match Table)的数组。我觉得理解KMP的最大障碍就是很多人在看了很多关于KMP的文章之后，仍然搞不懂PMT中的值代表了什么意思。这里我们抛开所有的枝枝蔓蔓，先来解释一下这个数据到底是什么。

对于字符串“abababca”，它的PMT如下表所示：

就像例子中所示的，如果待匹配的模式字符串有8个字符，那么PMT就会有8个值。

我先解释一下字符串的前缀和后缀。如果字符串A和B，存在A=BS，其中S是任意的非空字符串，那就称B为A的前缀。例如，”Harry”的前缀包括{”H”, ”Ha”, ”Har”, ”Harr”}，我们把所有前缀组成的集合，称为字符串的前缀集合。同样可以定义后缀A=SB，其中S是任意的非空字符串，那就称B为A的后缀，例如，”Potter”的后缀包括{”otter”, ”tter”, ”ter”, ”er”, ”r”}，然后把所有后缀组成的集合，称为字符串的后缀集合。要注意的是，字符串本身并不是自己的后缀。

有了这个定义，就可以说明PMT中的值的意义了。PMT中的值是字符串的前缀集合与后缀集合的交集中最长元素的长度。例如，对于”aba”，它的前缀集合为{”a”, ”ab”}，后缀集合为{”ba”, ”a”}。两个集合的交集为{”a”}，那么长度最长的元素就是字符串”a”了，长度为1，所以对于”aba”而言，它在PMT表中对应的值就是1。再比如，对于字符串”ababa”，它的前缀集合为{”a”, ”ab”, ”aba”, ”abab”}，它的后缀集合为{”baba”, ”aba”, ”ba”, ”a”}，两个集合的交集为{”a”, ”aba”}，其中最长的元素为”aba”，长度为3。

好了，解释清楚这个表是什么之后，我们再来看如何使用这个表来加速字符串的查找，以及这样用的道理是什么。

如图 1.12 所示，要在主字符串"ababababca"中查找模式字符串"abababca"。

如果在 j 处字符不匹配，那么由于前边所说的模式字符串 PMT 的性质，主字符串中 i 指针之前的 PMT[j −1] 位就一定与模式字符串的第 0 位至第 PMT[j−1] 位是相同的。这是因为主字符串在 i 位失配，也就意味着主字符串从 i−j 到 i 这一段是与模式字符串的 0 到 j 这一段是完全相同的。而我们上面也解释了，模式字符串从 0 到 j−1 ，在这个例子中就是”ababab”，其前缀集合与后缀集合的交集的最长元素为”abab”，长度为4。所以就可以断言，主字符串中i指针之前的 4 位一定与模式字符串的第0位至第 4 位是相同的，即长度为 4 的后缀与前缀相同。这样一来，我们就可以将这些字符段的比较省略掉。具体的做法是，保持i指针不动，然后将j指针指向模式字符串的PMT[j −1]位即可。

简言之，以图中的例子来说，在 i 处失配，那么主字符串和模式字符串的前边6位就是相同的。又因为模式字符串的前6位，它的前4位前缀和后4位后缀是相同的，所以我们推知主字符串i之前的4位和模式字符串开头的4位是相同的。就是图中的灰色部分。那这部分就不用再比较了。

有了上面的思路，我们就可以使用PMT加速字符串的查找了。我们看到如果是在 j 位失配，那么影响 j 指针回溯的位置的其实是第 j −1 位的 PMT 值，所以为了编程的方便，我们不直接使用PMT数组，而是将PMT数组向后偏移一位。我们把新得到的这个数组称为next数组。下面给出根据next数组进行字符串匹配加速的字符串匹配程序。其中要注意的一个技巧是，在把PMT进行向右偏移时，第0位的值，我们将其设成了-1，这只是为了编程的方便，并没有其他的意义。在本节的例子中，next数组如下表所示。

具体的程序如下所示：

int KMP(char * t, char * p)
{int i = 0; int j = 0;while (i < strlen(t) && j < strlen(p)){if (j == -1 || t[i] == p[j]) {i++;j++;}else j = next[j];}if (j == strlen(p))return i - j;else return -1;
}

好了，讲到这里，其实KMP算法的主体就已经讲解完了。你会发现，其实KMP算法的动机是很简单的，解决的方案也很简单。远没有很多教材和算法书里所讲的那么乱七八糟，只要搞明白了PMT的意义，其实整个算法都迎刃而解。

现在，我们再看一下如何编程快速求得next数组。其实，求next数组的过程完全可以看成字符串匹配的过程，即以模式字符串为主字符串，以模式字符串的前缀为目标字符串，一旦字符串匹配成功，那么当前的next值就是匹配成功的字符串的长度。

具体来说，就是从模式字符串的第一位(注意，不包括第0位)开始对自身进行匹配运算。在任一位置，能匹配的最长长度就是当前位置的next值。如下图所示。

求next数组值的程序如下所示：

void getNext(char * p, int * next) { next[0] = -1; int i = 0, j = -1; while (i < strlen(p)) { if (j == -1 || p[i] == p[j]) { ++i; ++j; next[i] = j; } else j = next[j]; } }

至此，KMP算法就全部介绍完了。

作者：海纳
链接：https://www.zhihu.com/question/21923021/answer/281346746
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

模式搜索的KMP算法详解与C语言代码实现

模式搜索的KMP算法

如何更好地理解和掌握 KMP 算法?

推荐文章：

模式搜索的KMP算法详解与C语言代码实现相关推荐

最新文章

热门文章