【重学数据结构与算法(JS)】字符串匹配算法(二)——KMP算法

前言

在上一篇文章字符串匹配算法(一)——BF算法提到过，字符串匹配的思路是固定的：

1. 将模式串和主串进行比较

   • 从前日后比较
   • 从后往前比较
2. 匹配时，比较主串和模式串的下一个位置

3. 失配时,

   • 在模式串中寻找一个合适的位置

     • 若是找到，从这个位置开始与主串当前失配位置进行比较
     • 若是未找到，从模式串的头部与主串失配位置的下一个位置进行比较
   • 在主串中找到一个合适的位置，从新与模式串进行比较

优化在于其中的步骤，而KMP算法，就是优化第3步失配时寻找模式串合适位置的操做。

算法介绍和分析

那么如何寻找模式串中所谓合适的位置呢？能够先来看个栗子：

......

上面是 BF 匹配过程当中从N_k到N_k+m的 m 次匹配过程，从中咱们能够发现，从第 k 步到第 k+m 步时，指针 i 和 j 又回到了相同的位置，且 第 k+m 步 更具备匹配的可能性，因此咱们思考一下，是否是能够由第 k 步直接跳到第 k+m 步呢？若是能够，就能够减小 m-1 次比较，大大提高效率。再进一步思考，若是将整个匹配过程再看做是重复地由N_k直接到N_k+m的推动，那么每次重复时，模式串开始比较的位置就是咱们所要找的合适的位置。

如何寻找这些位置呢？咱们能够把这个问题转化为求next数组的过程。

求 next 数组

咱们再仔细观察下 N_k 和 N_k+m 两个状态

因为 N_k 状态下，模式串与主串具备彻底匹配的部分，且要达到 N_k+m 状态所需移动到的位置信息也存在于匹配的部分，所以咱们能够无视掉主串，只看模式串便可获得next数组。

再认真观察咱们还能发现，N_k 状态不匹配时，N_k+m 状态本质上是将模式串中的另一对 AB 和 主串 达成以前的已匹配状态。因此求next数组的问题又能够转化为当m位置不匹配时，求m位置以前的子串的最大相同先后缀的问题。

首先要创建一个规则，具备先后缀的字符串长度至少为2，因此咱们定义若是长度为0，则对应next数组值为-1，若是长度为1，值为0。下面举个栗子：

ABABABD

手工求这么看其实没什么难度，本身多写几个串练一遍就会了。

代码

学会如何手工求next数组以后，整个KMP算法的代码如何写呢？
还记得最开始提到要记住的一点吗？匹配思路是同样的，只是优化了失配后的操做。根据这一点，咱们能够把BF算法的框架先搬过来：

这样是否是能够接下来去补全 getNext() 方法就能够了呢？咱们来看一个特殊状况：

当处在N_k+m状态时，发现失配位置前的 AB 没有最长公共先后缀，因而只能退回到BF算法的作法，也就是i++;j=0。可是这和咱们上面的框架代码不符，须要进行改造：

• 每当 j = next[j] === -1 时，也须要进入第一个分支，使得 i++;j++(-1 + 1 = 0），变相达到效果。

获得最终的框架代码：

接下来就是进行对next数组的求解——完善 getNext()。这时候有的同窗可能就会想对上述手工求法进行代码转化，但是万一模式串很长的话，那么这个时间复杂度就会变得至关的高，因此须要采用迭代法，利用每次所得的结果来求下一个结果，从而拼凑出next数组。

咱们假设某一时刻有一个状态S_k

此时咱们已经求完了next[j]的值，如何去求next[j+1]呢？仔细观察状态图，发现：

• 若P_k === P_j，则 P_j+1 前有next[j] + 1 = 4个相同的先后缀 P₀P₁P_k-jP_k 和 P_j-kP_j-k+1P_j-1P_j，也就是 next[j+1] = next[j] +1 = k + 1

再来看一个状态

一样是求完了next[j]的值，

• 若P_k === P_j，对比 P_next[k] 是否 等于 P_j；若是 P_nextⁿ[k] === P_j，则next[j+1] = P_nextⁿ[k] + 1 = k + 1

若是 P_nextⁿ[k] !== P_j呢？

能够看到，

• 若是P_nextⁿ[k] !== P_j，则不断地递归前缀索引 k = next[k] 直到回到前缀第一个位置，则表示没有相同的先后缀，此时 j = -1，则 next[j+1] = P_nextⁿ[k] + 1 = k + 1 = 0

根据以上分析，咱们能够补充完 getNext()

再优化一下写法

至此，一个完整的KMP算法就写好了。

思考是否还有优化的空间

咱们来看一个特殊的例子：

这是一个前缀相同的一个模式串，且咱们已经求得了next数组，接下来咱们模拟一下上面写好的程序进行的操做：

1. j = 5，needle[5] !== haystack[i]；next[j] = 4，j = next[j];
2. j = 4，needle[4] !== haystack[i]；next[j] = 3，j = next[j];
3. j = 3，needle[3] !== haystack[i]；next[j] = 2，j = next[j];
4. j = 2，needle[2] !== haystack[i]；next[j] = 1，j = next[j];
5. j = 1，needle[1] !== haystack[i]；next[j] = 0，j = next[j];
6. j = 0，needle[0] !== haystack[i]；next[j] = -1，j = next[j];
7. j = -1, j++;i++;

咱们发现因为前缀都是相等的，当第1步发现失配时，直接 j = -1 就能够了，也就是 next[5] = -1 便可。因此，优化点实际上是体如今对next数组的优化，咱们称之为nextVal数组

求nextVal数组

如何求nextVal数组呢？咱们仍是以上面的特殊状况为例，看两个状态：

此时咱们已经求完了nextVal[j]的值，仔细观察状态图，发现：

• 根据求next数组的过程,next[j + 1] = k + 1

  • 若P_j+1 !== P_{next[j + 1]}，在P_{next[j + 1]}发生失配时，只要跳到P_j+1就有可能解决失配问题，则此时的 nextVal[j + 1] = next[j + 1]便可
  • 若P_j+1 === P_{next[j + 1]}，在P_{next[j + 1]}发生失配时，跳到P_j+1就并不能解决失配问题，则此时应该继续回溯nextVal的next[j + 1]的位置上（因为是迭代求法，此时nextVal[next[j + 1]]上的值必定是经过nextVal[next²[j + 1]]求得了），即 nextVal[j + 1] = nextVal[next[j + 1]]

能够在 getNext() 的基础上获得如下代码：

next数组如今就已是一个无关紧要的工具人了，咱们把去掉，获得下一版代码：

再进行如下优化获得最终代码：

总结

总的来讲，KMP算法和BF算法的字符串匹配思路在大方向上是没有区别的，只是引入了一个next数组或nextVal数组来求得模式串中合适的位置。只要理解了这两个数组的求法，也就基本理解了KMP算法。

后记

“字符串匹配算法”是“重学数据结构与算法”系列笔记：

• 字符串匹配算法(一)——BF算法
• 字符串匹配算法(二)——KMP算法
• [字符串匹配算法(三)——BM算法]()
• [字符串匹配算法(四)——Sunday算法]()