5.7.3　KMP模式匹配算法实现

说了这么多，我们可以来看看代码了。

  1. /* 通过计算返回子串T的next数组。 */
  2. void get_next(String T, int *next)
  3. {
  4.     int i, j;
  5.     i = 1;
  6.     j = 0;
  7.     next[1] = 0;
  8.     /* 此处T[0]表示串T的长度 */
  9.     while (i < T[0])                   
  10.     {
  11.         /* T[i]表示后缀的单个字符， */
  12.         /* T[j]表示前缀的单个字符 */
  13.         if (j == 0 || T[i] == T[j])    
  14.         {
  15.             ++i;
  16.             ++j;
  17.             next[i] = j;
  18.         }
  19.         else
  20.             /* 若字符不相同，则j值回溯 */
  21.             j = next[j];               
  22.     }
  23. }

这段代码的目的就是为了计算出当前要匹配的串T的next数组。

  1. /* 返回子串T在主串S中第pos个字符之后的位置。
  2.    若不存在，则函数返回值为0。 */
  3. /* T非空，1≤pos≤StrLength(S)。 */
  4. int Index_KMP(String S, String T, int pos)
  5. {
  6.     /* i用于主串S当前位置下标值，若pos不为1， */
  7.     /* 则从pos位置开始匹配 */
  8.     int i = pos;                       
  9.     /* j用于子串T中当前位置下标值 */
  10.     int j = 1;                         
  11.     /* 定义一next数组 */
  12.     int next[255];                     
  13.     /* 对串T作分析，得到next数组 */
  14.     get_next(T, next);                 
  15.     /* 若i小于S的长度且j小于T的长度时， */
  16.     /* 循环继续 */
  17.     while (i <= S[0] && j <= T[0])     
  18.     {
  19.         /* 两字母相等则继续，相对于朴素算法增加了 */
  20.         /* j=0判断 */
  21.         if (j == 0 || S[i] == T[j])    
  22.         {
  23.             ++i;
  24.             ++j;
  25.         }
  26.         /* 指针后退重新开始匹配 */
  27.         else                           
  28.         {
  29.             /* j退回合适的位置，i值不变 */
  30.             j = next[j];               
  31.         }
  32.     }
  33.     if (j > T[0])
  34.         return i - T[0];
  35.     else
  36.         return 0;
  37. }

加粗的为相对于朴素匹配算法增加的代码，改动不算大，关键就是去掉了i值回溯的部分。对于get_next函数来说，若T的长度为m，因只涉及到简单的单循环，其时间复杂度为O(m)，而由于i值的不回溯，使得index_KMP算法效率得到了提高，while循环的时间复杂度为O(n)。因此，整个算法的时间复杂度为O(n＋m)。相较于朴素模式匹配算法的O((n-m+1)*m)来说，是要好一些。

这里也需要强调，KMP算法仅当模式与主串之间存在许多“部分匹配”的情况下才体现出它的优势，否则两者差异并不明显。