kmp算法kmp算法全名叫Knuth-Morris-Pratt算法，由三个发明者命名，其中K就是著名科学家Donald

简介

kmp算法全名叫Knuth-Morris-Pratt算法，由三个发明者命名，其中K就是著名科学家Donald Knuth，也就是《计算机程序设计艺术》的作者。主要用来解决字符串匹配问题，解决字符串匹配最自然想到的就是暴力匹配，例如：判断"BBC ABCDAB ABCDABCDABDE"字符串中是否存在"ABCDABD"，首先找到主字符串中与"ABCDABD"第一个字符串第一个字符相等的位置，如下图所示：然后主字符串与匹配字符串都右移一位继续比较，直到字符串有一个字符，与匹配字符串中对应的字符不相同为止，如下图所示找到匹配字符不同这时，最自然的反应是，将主字符串整个后移一位，再从头与匹配字符串逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。怎么做到这一点呢？可以针对匹配字符串算出一张《部分匹配表》（Partial Match Table）。

部分匹配表

首先，要了解两个概念："前缀"和"后缀"。 "前缀"指除了最后一个字符以外，一个字符串的全部头部组合；"后缀"指除了第一个字符以外，一个字符串的全部尾部组合。 "部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。以"ABCDABD"为例：

"A"的前缀和后缀都为空集，共有元素的长度为0；
"AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；
"ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；
"ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；
"ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；
"ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；
"ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。回到上边的例子得出"ABCDABD"的部分匹配数组[0,0,0,0,1,2,0]。

kmp思想

得出部分匹配数组后，当匹配字符串在比对过程中与主字符串发现不匹配的过程时候不是直接回退到首位而是根据当前位置到部分匹配数组中找到需要回退的位置，按照移动位数 = 已匹配的字符数 - 对应的部分匹配值公式可以计算出需要移动的位置。例如上边的例子"ABCDAB"是已经匹配的内容，长度为6，最后匹配的字符B在部分匹配数组中回退的位置是2，所以移动位数为6-2=4

因为空格与A不匹配，继续后移一位。逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动7位，这里就不再重复了。

编码

主函数如下

export function kmp(mainStr: string, subStr: string): number {
  if (!subStr) {
    return mainStr === subStr ? 0 : -1;
  }
  let i = 0,
    j = 0;
  const next: number[] = [];
  getNext(next, subStr);
  while (i < mainStr.length && j < subStr.length) {
    if (j === -1 || mainStr[i] === subStr[j]) {
      i++;
      j++;
    } else {
      j = next[j];
    }
  }
  if (j >= subStr.length) {
    return i - subStr.length;
  } else {
    return -1;
  }
}

回退函数

getNext函数就是得到部分匹配数组，i就是后缀指针的位置，j就是前缀的指针位置，同时j也是当前前缀与后缀相同的交集位置

function getNext(next: number[], str: string) {
  let i = 0,
    j = -1;
  next[0] = -1;
  while (i < str.length) {
    if (str[i] === str[j] || j === -1) {
      i++;
      j++;
      if (str[i] === str[j]) {
        next[i] = next[j];
      } else {
        next[i] = j;
      }
    } else {
      j = next[j];
    }
  }
}

整体思路：

初始化next[0]=-1,当匹配位置为字符串首位，没有可回退的上级位置
当前后缀指针所指字符串相等，移动前后缀指针位置，如果新的位置的字符串相等，将next[i]赋值为前缀指针回退数组中的回退位置，因为两边值相等，那么回退的位置也是一样的，如果位置的字符串不相等，那么后缀指针位置的回退位置就是当前前缀指针所指向的位置
当前后缀指针所指字符串不相等，移动前缀指针位置到对应的回退位置，因为回退函数也等于是一个字符串匹配过程，当前后缀指针位置的字符串不相等需要做一个回退

最终代码

export function kmp(mainStr: string, subStr: string): number {
  if (!subStr) {
    return mainStr === subStr ? 0 : -1;
  }
  let i = 0,
    j = 0;
  const next: number[] = [];
  getNext(next, subStr);
  while (i < mainStr.length && j < subStr.length) {
    if (j === -1 || mainStr[i] === subStr[j]) {
      i++;
      j++;
    } else {
      j = next[j];
    }
  }
  if (j >= subStr.length) {
    return i - subStr.length;
  } else {
    return -1;
  }
}

function getNext(next: number[], str: string) {
  let i = 0,
    j = -1;
  next[0] = -1;
  while (i < str.length) {
    if (str[i] === str[j] || j === -1) {
      i++;
      j++;
      if (str[i] === str[j]) {
        next[i] = next[j];
      } else {
        next[i] = j;
      }
    } else {
      j = next[j];
    }
  }
}