KMP算法 - 掘金

假设给定两个字符串 F 和 S，怎么求 S 在 F 中出现的第一个位置？细想一下就能知道其实就是 JS 中 String 的实例方法 indexOf()的实现，像下面这样：

const father = "I AM YOUR FATHER";
const son = "YOUR FATHER ARE MY GRANDPA";
console.log(father.indexOf(son)); // 5

不过我们当然不能就直接使用indexOf，那就不叫算法了。本文将从最简单的解法开始，再讲解 KMP 算法的原理。

直接解法

也可以叫暴力解法，就是遍历母串，和子串一一匹配，直到子串全部匹配完毕，如果中间有匹配不上的情况，就把母串从上一次开始匹配的位置后移一位，子串从 0 开始匹配，重复这个过程，直到匹配上或者匹配不上。代码如下：

const strStr = function(f, s) {
  // s为空，直接返回
  if (s === "") {
    return 0;
  }
  let i = 0;
  let j = 0;
  while (i < f.length) {
    // 如果匹配，各自加一，继续匹配
    if (f.charAt(i) === s.charAt(j)) {
      i++;
      j++;
    } else {
      // 如果不匹配，i置为上一轮匹配的下一位，j置为0
      i = i - j + 1;
      j = 0;
    }
    // 全部匹配上，返回
    if (j === s.length) {
      return i - j;
    }
  }
  return -1;
};

按说上面的解法对咱来说已经满足需要了，但是有三位大佬看了这种解法说，垃圾，这也叫算法？于是，我们有了 KMP 算法。

KMP

什么叫 kmp？就是提出这种算法的三个人的名字的首字母缩写，我们要搞懂的是名字后面的解法。

上面的直接解法是粗暴的一一匹配，效率较低，kmp 三人发现可以利用匹配失败时某种信息减少匹配的次数，从而提升效率，这个信息就是这个算法的关键点。是什么信息呢？简单说就是子串在匹配失败位置之前的字符串的最大相同的前缀后缀的长度。比较拗口，断句来看就是，子串在匹配失败位置，之前的字符串的，最大相同的前缀后缀，的长度。

关键点在最大相同的前缀后缀，什么叫最大相同的前缀后缀？比如ABCDAB，最大相同前后缀是AB，长度是 2，比如123123，最大相同前后缀是123，长度是 3。

我们需要的就是这个长度，我们来看一下这个长度有什么用。

我们假设以下两个字符串：

const m = "ABCDAB ABCDABCDABD";
const p = "ABCDABD";

可以想到，当匹配到 m[6]、p[6]时，我们能获取到的信息是前六位匹配，前六位的最大相同前后缀长度是AB，长度为 2。当不匹配时，暴力解法的做法是将母串后移一位，子串从 0 开始重新匹配，我们先模拟一下这个过程：

当匹配到 m[6] p[6]时不匹配，m 后移一位从 m[1]开始，p 从 p[0]开始
m[1]和 p[0]不匹配，继续移位
m[2]和 p[0]不匹配，继续移位
一直到 m[4]和 p[0]，终于匹配上了 A，然后下一位的 B 也能匹配上，直到 m[6]，p[2]

而匹配上的这俩正好是我们的最大相同前后缀，相比从第 6 位没匹配上开始，m 位置没变，还是 6，p 从 6 移到了 2，这个 2 正好是上面最大相同前后缀的长度(缘分啊)，所以这个长度的作用就是当匹配不到时，子串回退到的索引。我们给存储子串每位最大相同前后缀长度的数组取名为 next，每次匹配不到时子串索引置为相应值即可。

那么这个 next 数组该怎么求呢？我们默认将第一位置为-1，因为第一位没匹配上也不能再向左移动了，代码如下：

const getNext = str => {
  let j = 0;
  let k = -1;
  const next = [-1];
  while (j < str.length - 1) {
    if (k === -1 || str[j] === str[k]) {
      j++;
      k++;
      next[j] = k;
    } else {
      k = next[k];
    }
  }
  return next;
};

所以结合上面这个方法，我们有:

const strStr = function(f, s) {
  // s为空，直接返回
  if (s === "") {
    return 0;
  }
  const next = getNext(s);
  let i = 0;
  let j = 0;
  while (i < f.length) {
    // 如果匹配，各自加一，继续匹配
    if (j === -1 || f.charAt(i) === s.charAt(j)) {
      i++;
      j++;
    } else {
      // 如果不匹配，i不用改变，j置为此位置最大前后缀的长度
      j = next[j];
    }
    // 全部匹配上，返回
    if (j === s.length) {
      return i - j;
    }
  }
  return -1;
};

上面便是 kmp 的解法，然鹅，还可以再优化，看以下例子：

当匹配不到时，下一步我们移动的位置应该是这样

example2.png

可以发现，这步匹配是完全没意义的，因为上一步的 B 已经不匹配，这步的 B 肯定也不匹配了。发生问题的原因在于 p[j] == p[next[j]]，移动到的值正好等于现在的，这步移动就可以省略掉，进一步提升效率。我们修改一下求 next 数组的方法，如下：

const getNext = str => {
  let j = 0;
  let k = -1;
  const next = [-1];
  while (j < str.length - 1) {
    if (k === -1 || str[j] === str[k]) {
      j++;
      k++;
      if (p[j] !== p[k]) {
        next[j] = k;
      } else {
        next[j] = next[k];
      }
    } else {
      k = next[k];
    }
  }
  return next;
};

OK，以上便是 kmp 解法的讲解，我主要是用推导的方式，发现规律，里面其实是有数学公式佐证的，但是比较不好理解，就不贴出来了，有问题欢迎交流。

参考：