【原创】KMP算法详解

前言

KMP算法是学习数据结构 中的一大难点，不是说它有多难，而是它这个东西真的很难理解（反正我是这么感觉的，这两天我一直在研究KMP算法，总算感觉比较理解了这套算法，

在这里我将自己的思路分享给大家，也是检验一下自己有没有真正掌握这个算法，错误的地方也请大家指正。嘤嘤嘤~~~

注：可供参考的资料有很多，视频的话个人推荐B站的UP主正月点灯笼，博客的话有很多，不过不要贪多，不然容易混乱，不同的人对这个算法也是有不同的理解的！

 

背景

了解一个算法你要明白它的出处，KMP算法是由三位大牛同时研究出来的，他们分别是D.E.Knuth、J.H.Morris和V.R.Pratt，好吧其实明白他的出处也没太大用。。。（逃

那么KMP算法主要用来解决哪一方面的问题呢？ 主要是用来解决字符串中的模式串（通俗点说是关键字）在主串中的定位问题，比较通俗点说就是找你这个模式串在你这个主串的什么位置，并把它表示出来。

 

暴力匹配思路

看到这你就会感觉，这不是很简单吗，然后我们就会萌生下面这种思路：

有两个字符串：一个是“BDABCDBCDABCDAC”,另一个是“BCDAC”

直接从第一个字符开始比较，发现第一个字符相同，再往后找，发现第二个不相同，就把BCDAC往后移一位，从主串的第二个开始往后匹配，这不就完了？？简单粗暴！

但是其实这样做浪费了很多的时间，简单来说：

如果你的两个字符串是这样的：一个是“AAAAAAAAAAAAAAAAB”,另一个是“AB”

那么我们可以很清楚的发现一个问题，你的头是真的铁，那么我们应该怎么解决这个问题呢？这就要讲到我们的重点：KMP算法

 

NEXT数组

求next数组是KMP算法里面最为重要的一部分，求出这部分也就几乎成功了一半，那么我们求的这个数组到底是用来做什么的呢？其实是为了找到模式串失配后的下一个匹配位置

从而省去一些不必要的操作。求解next数组就不得不说到最长前后缀问题：

next数组的各元素是用来存放模式串的最长前后缀的长度，比如ABCDABD这个模式串，我们可以把它分成：

"A”、“AB”、“ABC”、“ABCD”、“ABCDA”、“ABCDAB”、“ABCDABD”七部分，

分别求得他们的最长前后缀（前后缀不包含自身）是：

“A”：0 

“AB”：0 

“ABC”：0

“ABCD”：0

”ABCDA“：1

”ABCDAB“：2

”ABCDABD“：0

所以我们得到的next数组为{0,0,0,0,1,2,0} 怎么样？很简单易懂吧，那么我们应该怎么用代码来实现呢？

一般来说我们都会把next数组的第一位设为0，因为第一个字符的最大前后缀始终为0，至于有的设为-1，虽然之前我都是按照-1做的，但那只是版本不同，我们这种的思路是比那种要清晰的。

代码实现如下：

void get_next(const char P[],int next[])
{
    int i,len;//i:模式串下标；len:最大前后缀的长度
    int m = strlen(P);//模式串长度
    next[0] = 0;//模式串的第一个字符的最大前后缀长度为0
    for (i = 1,len = 0; i < m; ++i)//从第二个字符开始，依次计算每一个字符对应的next值
    {
        while(len > 0 && P[i] != P[len])//递归的求出P[0]···P[i]的最大的相同的前后缀长度len
            len = next[len-1];         
        if (P[i] == P[len])//如果相等，那么最大相同前后缀长度加1
        {
            len++;
        }
        next[i] = len;
　　}
}

看完上面这段代码以后，我们发现最难懂的地方就是上面的while循环了，至于为什么要这样写呢？ 你可以理解为：如果模式串ABCDABCC中，我们要填next[8]时，

发现C后的这个C和前面的ABCD中的D不相同，那么我们的len是不会变的，所以我们要确保它等于上一个字符的next值，因为上一个字符的next值指的是最大相同的字符数。

 

KMP算法

有了next数组，我们就可以很好地实现KMP算法了，下面给出代码：

void kmp(const char T[],const char P[],int next[])
{
    int n,m;
    int i,q;
    n = strlen(T);
    m = strlen(P);
    get_next(P,next);
    for (i = 0,q = 0; i < n; ++i)
    {
        while(q > 0 && P[q] != T[i])//如果模式串和主串不匹配，进入while循环，看不懂下面会讲
            q = next[q-1];
        if (P[q] == T[i])//如果二者匹配，q加一
        {
            q++;
        }
        if (q == m)//如果全部匹配成功了，输出位置
        {
            printf("%d\n",i-m+2);
        }
    }    
}

那么为什么要写while那一句呢？其实原因很简单，我们的next数组是表示的每一段的最长前后缀的长度，如果失配了，我们就会返回与模式串失配位置前相同的后面那一部分，

比如说主串为”ABCABDCABCDABD“，模式串为”ABCDABD“，

当我们进行到ABC后我们发现q=4时失配了，这时我们应该返回的应该是next[q-1]，即它前一位的next数组，即next[3]，即标红色的那一部分，从那再开始进行，

也就是应该进行   "ABCDABD"，这样以此类推，仔细想想是不是这样，这一段和next数组都是比较难理解的，但也是最关键的。

 

总结

相信各位巨巨在看完以上讲解以后也基本理解了KMP算法，把它从头到尾想一遍，发现其实它也不是很难，无非就是找一个next数组和进行一次KMP查找而已，接下来我们分析一下KMP算法的时间复杂度：

假设现在主串T匹配到 i 位置，模式串P匹配到 q 位置

1. 　如果q>0并且P[q] ! = T[i]，即匹配失败那么q=next[q-1]，模式串也就相当于主串向右移动了q-next [q-1] 位。
2. 　如果P[q]==T[i]，表示匹配成功，那么q++，往后移。

我们发现如果某个字符匹配成功，模式串q++；如果匹配失配，i 不变（即 i 不回溯），模式串会跳过匹配过的next [q-1]个字符。

当然我们做最坏的打算，当模式串首字符位于i-(q-1)的位置时才匹配成功，算法结束。
所以，如果主串的长度为n，模式串的长度为m，那么匹配过程的时间复杂度为O(n)，加上计算next的O(m)时间，KMP的整体时间复杂度为O(m + n)。

　　

代码

#include<stdio.h>
#include<string.h>
void get_next(const char P[],int next[])
{
    int i,len;//i:模式串下标；len:最大前后缀的长度
    int m = strlen(P);//模式串长度
    next[0] = 0;//模式串的第一个字符的最大前后缀长度为0
    for (i = 1,len = 0; i < m; ++i)//从第二个字符开始，依次计算每一个字符对应的next值
    {
        while(len > 0 && P[i] != P[len])//递归的求出P[0]···P[i]的最大的相同的前后缀长度len
            len = next[len-1];
        if (P[i] == P[len])//如果相等，那么最大相同前后缀长度加1
        {
            len++;
        }
        next[i]=len;
    }
}

void kmp(const char T[],const char P[],int next[])
{
    int n,m;
    int i,q;
    n = strlen(T);
    m = strlen(P);
    get_next(P,next);
    for (i = 0,q = 0; i < n; ++i)
    {
        while(q > 0 && P[q] != T[i])//如果模式串和主串不匹配，进入while循环，看不懂下面会讲
            q = next[q-1];
        if (P[q] == T[i])//如果二者匹配，q加一
        {
            q++;
        }
        if (q == m)//如果全部匹配成功了，输出位置
        {
            printf("%d\n",i-m+1);
        }
    }
}

int main()
{
    int i;
    int next[20]={0};
    char T[] = "ABCABDCABCDABD";
    char P[] = "ABCDABD";
    printf("主串：%s\n",T);
    printf("模式串：%s\n\n",P );
    // get_next(P,next);
    printf("位置：");
    kmp(T,P,next);
    printf("\n");
    printf("next数组：\n");
    for (i = 0; i < strlen(P); ++i)
    {
        printf("%d ",next[i]);
    }
    printf("\n");
    return 0;
}

 

后记

花了两个多小时，终于是打完了，KMP的讲解就到这里了，关于KMP的各项优化这里也就不再多说，感兴趣的话可以去baidu搜索BM算法和Sunday算法，

如果发现上文有什么错误之处，还请随时指正，谢谢！

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　------------BY 孑、然---------------

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--------2018.8.18   11:01---------

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　---------------------------------------

转载于:https://www.cnblogs.com/jkxsz2333/p/9496534.html