字符串模式匹配算法系列（二）：KMP算法

算法背景：

KMP算法是由Donald Knuth和Vaughan Pratt于1970年共同提出的，而James H.Morris也几乎同时间独立提出了这个算法。因此人们将其称作“克努特-莫里斯-普拉特”算法（简称KMP）。

KMP算法的学习，可以在掌握了BF算法原理、并结合“BF算法效率低”作为切入点来理解，这样感觉比较符合大家的思维习惯。

算法原理：

上一篇博文《BF算法》的最后，有提到BF算法每次发现不匹配时，目标字符串只能向后挪动一个字符的距离，隐约感觉这样效率很低。

所以自然想到：发现不匹配时，目标字符串能不能向后多挪动几个字符的距离、从而加快整个算法的速度？甚至说极端一些，直接把目标字符串挪动到不匹配的位置上然后继续呢？

    

观察上面两张图，可以发现，向后挪动太多了是不行的，这样可能错过了原本可以匹配的基准点：

小结一下：

BF算法，是把目标字符串向后挪动一个字符（第一轮在下标0的位置上，第二轮挪到下标1、第三轮挪到下标2、第四轮挪到下标3并匹配成功），这样可以确保不会错过可以匹配的基准点，但效率太低；

我们的新想法，是把目标字符串向后多挪动几个字符，但不确定应该挪动几个字符，如果挪多了，就会错过潜在可以匹配的基准点（就像上面说的极端情况：一次向后挪动了6个位置，结果错过了下标3的那个可以匹配的基准点）

既想把目标字符串向后多挪动几个字符、从而加快速度，但又不能因为挪动的太快太多、而错过了原本可以匹配的字符。怎样才能同时做到这两点？

KMP算法，就是预先计算好这个应该挪动的字符数，这样问题就迎刃而解：即加快了向后挪动目标字符串的距离，又确保不会错过可能匹配的基准点。

---

我们仍然借用整个算法的执行过程，来说明“应该挪动的字符数”是如何确定的，然后再说明其是可以提前计算好的。

假定现在的不匹配点在下标6的位置，因此要计算目标字符串前面的字符串“非常地非常地”的最大向后挪动距离。

首先可以看到，下标6前面的字符串是“非常地非常地”，这个字符串在源字符串和目标字符串里是一样的（肯定是一样的，不然也不会到下标6才发现不匹配……），我们将其称作匹配子串。

仔细想一下：此时目标字符串向后挪动一段“恰当”的距离，是因为：挪动后的目标字符串中的匹配子串的前n个字符，与源字符串中的匹配子串的后n个字符有可能会匹配上。

因为我们不能错过这个潜在的匹配，所以才不能像前文说的那样，一次挪动的太多：

将上面两段描述综合起来看，其实就是在寻找：不匹配点前面的匹配子串的相同且最长的前n个字符和后n个字符，我们来实际演示一下寻找过程：

综上，下标6的这个不匹配点，它的匹配子串“非常地非常地”的长度为6，其前3个字符和后3个字符一样，即n=3

所以目标字符串可以向后挪动的距离就是6-3=3个位置（到下标3），这样就加快了挪动速度，又不会错过潜在的匹配基准点。

---

为了巩固说明，再举一个类似的例子，我们换一个目标字符串为：“非常地喜欢”，则现在不匹配点是在下标3的位置：

拿到下标3前面的字符串“非常地”，计算其相同且最长的前n个字符和后n个字符

进而得到结论，“非常地”没有相同的前、后n个字符，即n=0。

匹配子串的长尾为3，其中没有相同的前后n个字符（n为0），所以就可以直接让目标字符串向后移动3-0=3个位置，并开始新一轮匹配：

类似地，匹配子串长尾是3，相同且最长的前后n个字符没有找到，即n=0，所以目标字符串可以再向后移动3-0=3个字符，并开始新一轮匹配：

最终匹配成功。

---

从上面的例子可以看到几个现象：

1. “可以向后挪动的距离” = 位置 - 最长且相同的前/后缀子串

2. 在实际执行匹配算法之前，1可以只依靠目标字符串得到

3. 在实际使用算法之前无法知道具体在哪个位置不匹配，所以只能假设目标字符串每个位置都可能不匹配，并将不匹配点前面部分作为匹配子串来计算“相同且最长的前、后n个字符”，进而结合当前位置，得到这个不匹配点上可以向后挪动的距离。

进一步，可以将每个位置的【配置子串中最长且相同的前/后缀串】存储成为一个备份表，在实际算法执行时，根据目标字符串不匹配的实际位置，直接查询这张备份表，两者相减就可以得到此时此刻向后挪动的距离。这张备份表的学名就是【部分匹配表】

举个例子，如果目标字符串为“非常地非常地喜欢”，则其【部分匹配表】的内容为：

强调一下：部分匹配表中每一列的部分匹配表的值，是以其前面的子串来计算的。例如：位置6的“喜”字，其部分匹配表的值（3），是根据其前面的匹配子串“非常地非常地”计算来的，而不是“非常地非常地喜”（即不包括本身）！

实际使用时，用对应的位置值 - 备份表的值，就是目标字符串可以向后移动的距离。例如：位置6不匹配了，其目标字符串可以向挪动：6-3=3个位置。如果位置7不匹配了，目标字符串可以向后挪动7-0=7个位置。

类似地，如果目标字符串为“非常地喜欢”，则其部分匹配表的内容为：

这张部分匹配表所有值都是0，说明任何位置不匹配都可以直接跳到不匹配点重新比较，这种情况无疑是速度最快的情况。

由此也可以看出，目标字符串里前后重复的字符越少，目标字符串向后挪动的速度就越快，整个算法的效率就越高。

---

下面介绍一下【部分匹配表】的计算过程。

（此处稍后补充）

算法实现

KMP的python实现如下：

 #!/usr/bin/env python
 #-*- coding: utf-8 -*-
 import sys

 reload(sys)
 sys.setdefaultencoding('utf-8')

 class KMP(object):
     """KMP算法
     成员变量:
         s: 源字符串
         t: 目标字符串
         pmt: 部分匹配表(向右挪动了1格, 位置0赋-1)
     """
     def __init__(self, s, t):
         self.s = s
         self.t = t
         self.pmt = {}

     def _get_pmt_1(self):
         """根据目标字符串，计算前后缀的最大重复子串
         此方法简单，但dn指针可能回退到-1，且up不是每次都递增，所以while循环次数最多可能是t长度的两倍
         """
         self.pmt[0] = -1 # 位置0赋值-1，为了计算方便
         up = 0 # up表示上指针，用来向后移动从而实现错位
         dn = -1 # dn表示下指针，用来记录匹配的位置

         while up < len(self.t):
             if dn == -1 or self.t[up] == self.t[dn]:
                 up += 1
                 dn += 1
                 self.pmt[up] = dn
             else:
                 dn = self.pmt[dn]

     def _get_pmt_2(self):
         """根据目标字符串，计算前后缀的最大重复子串
         此方法略复杂，但dn指针不后退且up每次都递增1，所以while循环次数为t的长度
         """
         self.pmt[0] = -1 # 位置0赋值-1，为了计算方便
         self.pmt[1] = 0 # 位置1赋值0，表示没有匹配
         up = 1 # up表示上指针，用来向后移动从而实现错位
         dn = 0 # dn表示下指针，用来记录匹配的位置
         same_len = 0 # 表示匹配的字符串长度

         while up < len(self.t):
             if self.t[up] == self.t[dn]:
                 dn += 1
                 same_len += 1
             else:
                 same_len = 0
             up += 1
             self.pmt[up] = same_len

     def run_1(self):
         """完全匹配则返回源字符串匹配成功的起始点的下标，否则返回-1
         此方法简单，但循环次数比run_2多一倍
         """
         ptr_s = 0
         ptr_t = 0

         # 获取pmt
         self._get_pmt_1() #也可以用self._get_pmt_2()

         while ptr_t == -1 or ptr_s < len(self.s) and ptr_t < len(self.t):
             if self.s[ptr_s] == self.t[ptr_t]:
                 ptr_s += 1
                 ptr_t += 1
             else:
                 ptr_t = self.pmt[ptr_t]

         if ptr_t == len(self.t):
             return ptr_s - ptr_t
         return -1

     def run_2(self):
         """完全匹配则返回源字符串匹配成功的起始点的下标，否则返回-1
         此方法复杂，但循环次数比run_1少一半
         """
         base = 0
         same_len = 0
         len_s = len(str_s)
         len_t = len(str_t)

         # 获取pmt
         self._get_pmt_2() #也可以用self._get_pmt_1()

         while base + len_t <= len_s:
             step = 0
             while step + same_len < len_t:
                 if self.t[step + same_len] == self.s[base + step + same_len]:
                     # 当前字符相同，则继续比较下一个字符
                     step += 1
                     continue
                 # 当前字符不相同，则结束次轮比较，更新base基准位置，启动下一轮比较
                 same_len = self.pmt[step]
                 base += step - same_len
                 break
             # 完全匹配成功，算法结论，返回匹配成功的基准点位置下标
             if step + same_len == len_t:
                 return base
         # 遍历了所有情况，最终匹配失败，返回-1
         return -1

 if __name__ == '__main__':
     str_s = u"非常地非常地非常地喜欢你"
     str_t = u"非常地喜欢"
     model = KMP(str_s, str_t)
     print model.run_2()

算法评估

假设源字符串长度为m，目标字符串长度为n

KMP的时间复杂度为O(m+n)

KMP的空间复杂度为O(n)，因为多了一个和目标字符串相同长度的备份表