2021-02-28

最新推荐文章于 2022-03-23 14:16:21 发布

Augusdi

最新推荐文章于 2022-03-23 14:16:21 发布

阅读量431

点赞数

分类专栏： DataStructure

原文链接：https://blog.csdn.net/ithomer/article/details/7109440

版权

DataStructure 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

KMP字符串匹配算法

KMP算法，Knuth-Morris-Pratt Algorithm，一种由Knuth(D.E.Knuth)、Morris(J.H.Morris)和Pratt(V.R.Pratt)三人提出的一种快速模式匹配算法。

KMP朴素算法

原理：子串pattern依次与目标串target中的字符比较，如果相等，继续比较下一个字符；如果不等，pattern右移一位，重新开始比较，直至匹配正确或超出target。

示例：子串pattern={aabaa}，目标串target={aababaacaabaa}，比较过程如下图：

特点：思路简单、代码直观；但效率低、有回溯、不够简洁、时间复杂度高

// 在target中查找子串pattern的起始位置，pos初始为0
int index(char *target, char *pattern, int pos)
{
   if(NULL == target || NULL == pattern){
       return -1;
   }

   int k = pos, j = 0;
   while(k<strlen(target) && j<strlen(pattern)){       // 未超出字符串长度
       if(target[k] == pattern[j]){                   // 字符相同，则继续向后比较
           k++;
           j++;
       }else{                                           // 如果不同，则回溯重新查找
           k = k - j + 1;
           j = 0;
       }
   }

   if(j == strlen(pattern)){                       // 如果找到，则返回字串起始位置(首次匹配)
       return k - strlen(pattern);
   }else{                                           // 如果没找到，则返回-1
       return -1;
   }
}
小结：在最坏的情况下，每次比较都在最后一个字符出现不等（如aaaaaaaaaaaaab和ab）

假设pattern长度为m，target长度为n，则每趟最多比较m次，最多循环比较（n-m）趟，总比较次数为m*(n-m)，即时间复杂度为O（m*n）

KMP算法的演变

我们由上面KMP朴素算法的例子来引出一个问题。

为了便于问题分析，令P（pattern），T（target），字符数组下标从0开始。通过仔细分析，发现P（Pattern）前4个字符是匹配的，只有最后一个字符P[4]不匹配！

如果P右移1位，P前两字符aa又将与T（target）的ab不匹配

如果P右移2位，P第一个字符a就与T的b不匹配

如果P右移3位，P前两字符aa又将于T的ab不匹配（同右移1位的情况）

如果P右移4位，P第一个字符a就与T的b不匹配（同右移2位的情况）

如果P右移5位，即P跨过已经与T比较过的五位了，省去了右移1、2、3、4位的步骤

为什么是5位呢？我们再深入分析，转换思考问题的侧重点，发现5位字符正好是P（Pattern）子串的长度，是不是P子串本身就蕴含了模式匹配的奥秘？

答案是肯定的！

P： aabaa(X) 注意：最后一个字符不匹配，即a(X)

上图直观给出，P要么右移3位，要么右移5位，才有可能与T（target）出现匹配。

我们探索P本身的规律，发现P（aabaa）移位的大小，与其自身的首尾覆盖特性有关，即aa—b—aa（移3位跳过b字符，移5位跳过自身，从头开始比较）

于是我们引出了另外一个问题——覆盖函数

什么是覆盖函数呢？我们直接给出定义：

对于序列

找出这样一个k，使其满足

并且要求k尽可能的大！（原因后面再讲）

求P自身最大的k值，对于P（pattern）的前j序列字符(从下标0计起)，有两种可能：

1、 pattern[j] == pattern[preOverlay+1] 时，overlay(j) = preOverlay + 1 = overlay(j-1) + 1

2、 pattern[j] != pattern[preOverlay+1] 时，overlay(j)需要在前preOverlay中找；使preOverlay = overlay[preOverlay]，重复2过程

// 求pattern覆盖
void overlay_Pattern(const char *pattern)
{
   const int len = strlen(pattern);
   int *overlay = new int[len];
   int i, preOverlay;

   overlay[0] = -1;
   for(i=1; i<len; i++){
       preOverlay = overlay[i-1];

       while (preOverlay >= 0 && pattern[i] != pattern[preOverlay+1]){
           preOverlay = overlay[preOverlay];
       }

       if (pattern[i] == pattern[preOverlay+1]){
           overlay[i] = preOverlay + 1;
       }else{
           overlay[i] = -1;
       }
   }

   for(i=0; i<len; i++){
       printf("%d\n", overlay[i]);
   }

   delete []overlay;
}
示例：
例如P： aabaa 其overlay依次为：-1、0、-1、0、1
-1表示没有覆盖，0表示有一个覆盖，1表示有两个覆盖，从-1开始计起
再如P： abaabcabab 其overlay依次为：-1、-1、0、0、1、-1、0、1、2、1

KMP算法

KMP算法，是由KMP朴素算法演变而来的，主要分为两步：

第一步，当字符串比较出现不等时，确定下一趟比较前，应该将子串pattern右移多少个字符（预处理）

第二步，子串pattern右移后，应该从哪个字符开始和目标串target中刚才比较时不等的那个字符继续开始比较（查找）

下面给出完整的KMP算法：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 预处理子串
void kmp_Prepare(char *target, char *pattern, int *overlay)
{
   memset(overlay, 0, sizeof(overlay));

   int i = -1, j = 0, preOverlay;
   overlay[0] = -1;

   for(i=1; i<strlen(pattern); i++){
       preOverlay = overlay[i-1];

       while(preOverlay >= 0 && pattern[i] != pattern[preOverlay+1]){
           preOverlay = overlay[preOverlay];
       }

       if(pattern[i] == pattern[preOverlay+1]){
           overlay[i] = preOverlay + 1;
       }else{
           overlay[i] = -1;
       }
   }

   for(i=0; i<strlen(pattern); i++){
       printf("overlay[%d]: %d\n", i, overlay[i]);
   }
}

// 查询子串
int kmp_Find(char *target, char *pattern, int *overlay)
{
   int index_pattern = 0;
   int index_target = 0;

   while(index_pattern < strlen(pattern) && index_target < strlen(target)){
       if(target[index_target] == pattern[index_pattern]){
           index_target++;
           index_pattern++;
       }else if(index_pattern == 0){
           index_target++;
       }else{
           index_pattern = overlay[index_pattern - 1] + 1;
       }
   }

   if(index_pattern == strlen(pattern)){
       return index_target - index_pattern;
   }else{
       return -1;
   }
}

int main(int argc, char **argv)
{
   char *target = "aababaacaabaa";
   char *pattern = "aabaa";
   int *overlay = new int[strlen(pattern)];

   int index_s = -1;

   printf("target: %s, len: %d\n", target, strlen(target));
   printf("pattern: %s, len: %d\n", pattern, strlen(pattern));

   kmp_Prepare(target, pattern, overlay);
   index_s = kmp_Find(target, pattern, overlay);

   printf("index_s: %d\n", index_s);

   getchar();
   return 0;
}

测试示例：
pattern： aabaa

target： aababaacaabaa

运行结果：

总结：

第一步，其实就是KMP朴素算法对模式匹配子串pattern的预处理过程，上面已经给出了算法公式和代码示例

第二步，本质上就是KMP朴素算法，不同的仅仅是pattern右移的位数大小由其预处理过程决定

KMP算法不太容易理解，但其简洁、高效，时间复杂度为O(m+n)
其中，O(m)是pattern子串预处理的时间复杂度，O(n)是target目标串查找的时间复杂度，总时间复杂度为O(m+n)

KMP代码下载

参考推荐：

KMP（百度百科）

Knuth-Morris-Pratt algorithm（Wikipedia）

Knuth-Morris-Pratt algorithm（String Matching）

Knuth-Morris-Pratt string matching
————————————————
版权声明：本文为CSDN博主「阳光岛主」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ithomer/article/details/7109440

https://blog.csdn.net/ithomer/article/details/7109440