KMP算法详解之C++

  最近在深入的学习Linux上面的一些知识，感觉自己还欠缺很多，于是就开始动手学习。当我看到kmp算法的时候不知道它是干什么用的，在网上也翻阅了很多资料，有的写的还不错，有的写的很模糊；所以我也想写一篇关于KMP算法的详解（从我的角度），可能会有不好的地方，希望多多关照，敬请谅解！

---

 

简介

  KMP算法是一种改进的字符串匹配算法，有D.E.Knuth、J.H.Morris和V.R.Pratt三位大神提出来的，称之为Knuth-Morria-Pratt算法，简称KMP算法。该算法相对于Brute-Force（暴力）算法有比较大的改进，主要是消除了主串指针的回溯，从而使算法效率有了某种程度的提高。它的核心是利用匹配失败后的信息，尽量减少字符串与主串的匹配次数以达到快速匹配的目的。其时间复杂度为O(m+n)。
  所谓暴力算法，就是简单直接的进行字符串匹配，特别暴力，没有过多的讲究在里面，只是两组字符串一次进行遍历，其时间复杂度为O（n*m），效率不高，用一张动图将暴力算法展示出来：
 

KMP算法实现

  KMP算法是在暴力算法的基础上进行改进升级，它的实现逻辑主要分为两步分：一、创建模块串中的next；二、字符串匹配。

创建模块串中的next

  模块中的next，主要使用用于，当我们在进行模块串与文本进行对比的时候，若模块串中的某一个字符与文件中的字符对比不一致的时候，进行回溯用的。至于怎么对比将会在字符串匹配环节进行说明。那么，在这里主要说明的是模块串的next是怎么创建，或者说是生成的。
  若想真正理解清楚next，首先要弄清楚什么是字符串的前缀和后缀；前缀，是从第一个字符到倒数第二个字符的组合；后缀，是从第二个字符到最后一个字符的组合；需要注意的是，字符在组合时，不能有跳过某个或某几个字符进行组合，即字符的组合必须是相连续。以字符串“abcabcd”为例，如下所示：

abcabcd    前缀 prefix                           后缀 suffix                       最长且相同的字符串
a          p: 0                                 s: 0                              0     0
ab         p: a                                 s: b                              0     0
abc        p: a, ab                             s: c, bc                          0     0
abca       P: a, ab, abc                        s: a, ca, bca                     a     1
abcab      p: a, ab, abc, abca                  s: b, ab, cab, bcab               ab    2
abcabc     p: a, ab, abc, abca, abcab           s: c, bc, abc, cabc, bcabc        abc   3
abcabcd    p: a, ab, abc, abca, abcab, abcabc   s: d, cd, bcd, abcd, cabcd, bcabd 0     0

  找寻next是利用前缀和后缀所用的共同字符串，并获取当前最长的字符串的长度，通过上面的简单列举，发现字符串“abcabcd”的next为[0, 0, 0, 1, 2, 3, 0]，代码实现如下：

void create_next(char* pattern, int *next){
    int lenght = strlen(pattern);

    // 初始化前缀和后缀的index
    int prefix = 0, suffix = 1;
    for (prefix = 0, suffix = 1; suffix < lenght; ++suffix) {
        while (prefix > 0 && pattern[prefix] != pattern[suffix])
            prefix = next[prefix - 1];

        if (pattern[suffix] == pattern[prefix])
            ++ prefix;
        next[suffix] = prefix;
    }
}

字符串匹配

  当完成模块串中next创建后，就可以进行字符串的匹配查询。以“abcabcd”作为模块串pattern，“abcabcabcabcabcd”为待查询的text。

第一次字符串匹配
abcabcabcabcabcd
abcabcd

  第一次查询遍历，在’d‘字符进行对比的时不一致（模块串’d‘， text为’a‘），如上所示；此时我们需要索引index的回溯，那么怎么进行回溯呢？字符’d‘在模块串中的index是6，此时回溯的时候我们需要借助上一小节生成的next来进行回溯；在对比字符’d‘时，意味这模块串中的前六个字符“abcabc“对比一致；那么回溯的时候，我们要根据next[index-1] (index为不一致字符的索引值)拿到我们需要向前回溯的几个字符，发现需要回溯3个字符；那么将会从索引index-3的位置，重新开始字符串匹配；如下所示：

第一次回溯后，第二次字符串匹配
abcabcabcabcabcd
   abcabcd

第二次回溯后，第三次字符串匹配
abcabcabcabcabcd
      abcabcd

第三次回溯后，第四次字符串匹配
abcabcabcabcabcd
         abcabcd

  如上所示，我们只需要经历三次回溯、四次字符串匹配拿到结果；相比暴力算法，字符串匹配的次数减少了很多。那么，其代码实现的如下所示：

int kmp(char* text, char* pattern){
    int text_length = strlen(text);
    int pattern_length = strlen(pattern);

    int *next = new int[pattern_length];
    create_next(pattern, next);

    for (int i = 0; i < pattern_length; ++ i)
        std::cout << next[i] << " ";
    std::cout << std::endl;

    for(int i = 0, q = 0; i < text_length; ++ i){

        while(q > 0 && pattern[q] != text[i])
            q = next[q - 1];

        if (pattern[q] == text[i])
            q++;
        if (q == pattern_length) {
            delete[] next;
            return i - q + 1;
        }
    }

    delete[] next;
    return -1;
}

int main(int argc, cahr**argv){
	char *text = "abcabcabcabcabcd";
    char *pattern = "abcabcd";
    int index = kmp(text, pattern);
    std::cout << "match pattern: " << index << std::endl;
	return 0;
}