KMP算法

最新推荐文章于 2025-07-22 21:20:35 发布

原创最新推荐文章于 2025-07-22 21:20:35 发布 · 554 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #字符串匹配算法

算法专栏收录该内容

2 篇文章

订阅专栏

KMP算法

1. 暴力匹配算法

在讲KMP算法之前，我们先看看常规字符串匹配算法。

假设现在我们面临这样一个问题：有一个文本串S，和一个模式串P，现在要查找P在S中的位置，怎么查找呢？

如果用暴力匹配的思路，并假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置，则有：

如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；
如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j 被置为0。

理清楚了暴力匹配算法的流程及内在的逻辑，咱们可以写出暴力匹配的代码，如下：

 
         int 
         ViolentMatch(
         char
         * s, 
         char
         * p)  
        
         {  
        
         int 
         sLen = 
         strlen
         (s);  
        
         int 
         pLen = 
         strlen
         (p);  
        
         int 
         i = 0;  
        
         int 
         j = 0;  
        
         while 
         (i < sLen && j < pLen)  
        
         {  
        
         if 
         (s[i] == p[j])  
        
         {  
        
         //①如果当前字符匹配成功（即S[i] == P[j]），则i++，j++      
        
         i++;  
        
         j++;  
        
         }  
        
         else  
        
         {  
        
         //②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0      
        
         i = i - j + 1;  
        
         j = 0;  
        
         }  
        
         }  
        
         //匹配成功，返回模式串p在文本串s中的位置，否则返回-1  
        
         if 
         (j == pLen)  
        
         return 
         i - j;  
        
         else  
        
         return 
         -1;  
        
         }

2. KMP算法

2.1 KmpSearch函数

Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”，常用于在一个文本串S内查找一个模式串P 的出现位置，这个算法由Donald Knuth、Vaughan Pratt、James H. Morris三人于1977年联合发表，故取这3人的姓氏命名此算法。

假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置
- 如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++，继续匹配下一个字符；
- 如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]。此举意味着失配时，模式串P相对于文本串S向右移动了j - next [j] 位。
  - 换言之，当匹配失败时，模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值（next 数组的求解会在下文的中详细阐述），即移动的实际位数为：j - next[j]，且此值大于等于1。

很快，你也会意识到 next 数组各值的含义：代表当前字符之前的字符串中，有多大长度的相同前缀后缀（模串的固有性质）。 例如如果next [j] = k，代表j 之前的字符串中有最大长度为 k 的相同前缀后缀。

此也意味着在某个字符失配时，该字符对应的next 值会告诉你下一步匹配中，模式串应该跳到哪个位置（跳到next [j] 的位置）。如果next [j] 等于0或-1，则跳到模式串的开头字符，若next [j] = k 且 k > 0，代表下次匹配跳到j 之前的某个字符，而不是跳到开头，且具体跳过了k 个字符。

转换成代码表示，则是：

 
          int KmpSearch(char* s, char* p)  
         
          {  
         
          int i = 0;  
         
          int j = 0;  
         
          int sLen = strlen(s);  
         
          int pLen = strlen(p);  
         
          while 
          (i < sLen && j < pLen)  
         
          {  
         
          //①如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++      
         
          if 
          (j == -1 || s[i] == p[j])  
         
          {  
         
          i++;  
         
          j++;  
         
          }  
         
          else  
         
          {  
         
          //②如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]      
         
          //next[j]即为j所对应的next值        
         
          j = next[j];  
         
          }  
         
          }  
         
          if 
          (j == pLen)  
         
          return 
          i - j;  
         
          else  
         
          return 
          -1;  
         
          }

举例来说，当S[10]跟P[6]匹配失败时，KMP不是跟暴力匹配那样简单的把模式串右移一位，而是执行第②条指令：“如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]”，即j 从6变到2（后面我们将求得P[6]，即字符D对应的next 值为2），所以相当于模式串向右移动的位数为j - next[j]（j - next[j] = 6-2 = 4）。

向右移动4位后，S[10]跟P[2]继续匹配。为什么要向右移动4位呢，因为移动4位后，模式串中又有个“AB”可以继续跟S[8]S[9]对应着，从而不用让i 回溯。相当于在除去字符D的模式串子串中寻找相同的前缀和后缀，然后根据前缀后缀求出next 数组，最后基于next 数组进行匹配（不关心next 数组怎么求来的，只想看匹配过程是咋样的，可直接跳到下文）。

2.2 next数组求取

2.2.1 寻找最长前缀后缀

如果给定的模式串是：“ABCDABD”，从左至右遍历整个模式串，其各个子串的前缀后缀分别如下表格所示：

也就是说，原模式串子串对应的各个前缀后缀的公共元素的最大长度表为（ 下简称《最大长度表》）：

如下匹配，当模式串最后一个字符D跟文本串匹配时失配，显而易见，模式串需要向右移动。但向右移动多少位呢？因为此时已经匹配的字符数为6个（ABCDAB），然后根据《最大长度表》可得失配字符D的上一位字符B对应的长度值为2，所以根据之前的结论，可知需要向右移动6 - 2 = 4 位。

故可得出下述结论：

失配时，模式串向右移动的位数为：已匹配字符数 - 失配字符的上一位字符所对应的最大长度值

对于给定的模式串：ABCDABD，它的最大长度表及next 数组分别如下：

根据最大长度表求出了next 数组后，从而有

失配时，模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值

2.2.1 next数组

 
        void 
        GetNext(
        char
        * p,
        int 
        next[])  
       
        {  
       
        int 
        pLen = 
        strlen
        (p);  
       
        next[0] = -1;  
       
        int 
        k = -1;  
       
        int 
        j = 0;  
       
        while 
        (j < pLen - 1)  
       
        {  
       
        //p[k]表示前缀，p[j]表示后缀  
       
        if 
        (k == -1 || p[j] == p[k])   
       
        {  
       
        ++k;  
       
        ++j;  
       
        next[j] = k;  
       
        }  
       
        else   
       
        {  
       
        k = next[k];  
       
        }  
       
        }  
       
        }

Next 数组的优化

行文至此，咱们全面了解了暴力匹配的思路、KMP算法的原理、流程、流程之间的内在逻辑联系，以及next 数组的简单求解（《最大长度表》整体右移一位，然后初值赋为-1）和代码求解，最后基于《next 数组》的匹配，看似洋洋洒洒，清晰透彻，但以上忽略了一个小问题。

比如，如果用之前的next 数组方法求模式串“abab”的next 数组，可得其next 数组为-1 0 0 1（0 0 1 2整体右移一位，初值赋为-1），当它跟下图中的文本串去匹配的时候，发现b跟c失配，于是模式串右移j - next[j] = 3 - 1 =2位。

右移2位后，b又跟c失配。事实上，因为在上一步的匹配中，已经得知p[3] = b，与s[3] = c失配，而右移两位之后，让p[ next[3] ] = p[1] = b 再跟s[3]匹配时，必然失配。问题出在哪呢？

问题出在不该出现p[j] = p[ next[j] ]。为什么呢？理由是：当p[j] != s[i] 时，下次匹配必然是p[ next [j]] 跟s[i]匹配，如果p[j] = p[ next[j] ]，必然导致后一步匹配失败（因为p[j]已经跟s[i]失配，然后你还用跟p[j]等同的值p[next[j]]去跟s[i]匹配，很显然，必然失配），所以不能允许p[j] = p[ next[j ]]。如果出现了p[j] = p[ next[j] ]咋办呢？如果出现了，则需要再次递归，即令next[j] = next[ next[j] ]。

所以，咱们得修改下求next 数组的代码。

 
        //优化过后的next 数组求法  
       
        void 
        GetNextval(
        char
        * p, 
        int 
        next[])  
       
        {  
       
        int 
        pLen = 
        strlen
        (p);  
       
        next[0] = -1;  
       
        int 
        k = -1;  
       
        int 
        j = 0;  
       
        while 
        (j < pLen - 1)  
       
        {  
       
        //p[k]表示前缀，p[j]表示后缀    
       
        if 
        (k == -1 || p[j] == p[k])  
       
        {  
       
        ++j;  
       
        ++k;  
       
        //较之前next数组求法，改动在下面4行  
       
        if 
        (p[j] != p[k])  
       
        next[j] = k;   
        //之前只有这一行  
       
        else  
       
        //因为不能出现p[j] = p[ next[j ]]，所以当出现时需要继续递归，k = next[k] = next[next[k]]  
       
        next[j] = next[k];  
       
        }  
       
        else  
       
        {  
       
        k = next[k];  
       
        }  
       
        }  
       
        }