KMP算法的学习理解

最新推荐文章于 2023-01-17 23:23:10 发布

typersever

最新推荐文章于 2023-01-17 23:23:10 发布

阅读量840

点赞数

分类专栏：算法文章标签：算法 kmp

算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

有这样一道题目：KMP算法下，长为n的字符串中匹配长度为m的子串的复杂度为（）

a. O(N)

b. O(M+N)

c. O(N+LOGM)

d. O(M+LOGN)

时间复杂度，在KMP算法下，应该为 O（M+N）

KMP算法是什么呢？

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

引用以下的文章能很好地理解KMP算法的意义：原文地址链接点击这里

摘自：阮一峰先生的《字符串匹配的KMP算法》

字符串匹配是计算机的基本任务之一。

　　举例来说，有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？

　　许多算法可以完成这个任务，Knuth-Morris-Pratt算法（简称KMP）是最常用的之一。它以三个发明者命名，起头的那个K就是著名科学家Donald Knuth。

　　这种算法不太容易理解，网上有很多解释，但读起来都很费劲。直到读到Jake Boxer的文章，我才真正理解这种算法。下面，我用自己的语言，试图写一篇比较好懂的KMP算法解释。

　　首先，字符串"BBC ABCDAB ABCDABCDABDE"的第一个字符与搜索词"ABCDABD"的第一个字符，进行比较。因为B与A不匹配，所以搜索词后移一位。

　　因为B与A不匹配，搜索词再往后移。

　　就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

　　接着比较字符串和搜索词的下一个字符，还是相同。

　　直到字符串有一个字符，与搜索词对应的字符不相同为止。

　　这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。

　　一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。

　　怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）。这张表是如何产生的，后面再介绍，这里只要会用就可以了。

　　已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。查表可知，最后一个匹配字符B对应的"部分匹配值"为2，因此按照下面的公式算出向后移动的位数：

　　移动位数 = 已匹配的字符数 - 对应的部分匹配值

　　因为 6 - 2 等于4，所以将搜索词向后移动4位。

　　10.

　　因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（"AB"），对应的"部分匹配值"为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移2位。

　　11.

　　因为空格与A不匹配，继续后移一位。

　　12.

　　逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动4位。

　　13.

　　逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动7位，这里就不再重复了。

　　14.

　　下面介绍《部分匹配表》是如何产生的。

　　首先，要了解两个概念："前缀"和"后缀"。 "前缀"指除了最后一个字符以外，一个字符串的全部头部组合；"后缀"指除了第一个字符以外，一个字符串的全部尾部组合。

　　15.

　　"部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。以"ABCDABD"为例，

　　－　"A"的前缀和后缀都为空集，共有元素的长度为0；

　　－　"AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；

　　－　"ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

　　－　"ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

　　－　"ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；

　　－　"ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；

　　－　"ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

　　16.

　　"部分匹配"的实质是，有时候，字符串头部和尾部会有重复。比如，"ABCDAB"之中有两个"AB"，那么它的"部分匹配值"就是2（"AB"的长度）。搜索词移动的时候，第一个"AB"向后移动4位（字符串长度-部分匹配值），就可以来到第二个"AB"的位置。

（完）

这一算法还是存在缺陷的。当“部分匹配”没有能匹配到ABCDAB后面的两个AB处时，是不能使用上述的“部分“匹配值”2。有时候在向后移动的时候移动得不够多，还需要往后匹配，就像上面文章第11点那里的情况。更糟糕的是，有时候需要连续往后跳。这说明，这个方法还能继续优化。

如果先理解简单的匹配算法，会更好理解KMP

强行匹配算法：

 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;  

    }  
</span>

下面是真正的KMP算法详解

July老师的文章，说明得十分详细。这里不转载：原博客地址点击此处

下面粘贴 next [ j ] 的生成代码：

    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 数组求法  
    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];  
            }  
        }  
    }

//优化过后的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]; } } } //下面是KMP求法，结合上面的next算法，那么整个KMP算法就算大功告成

    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;  
    }

掌握KMP循序渐进把握好下面几点：

如果模式串中存在相同前缀和后缀，即pj-k pj-k+1, ..., pj-1 = p0 p1, ..., pk-1，那么在pj跟si失配后，让模式串的前缀p0 p1...pk-1对应着文本串si-k si-k+1...si-1，而后让pk跟si继续匹配。
之前本应是pj跟si匹配，结果失配了，失配后，令pk跟si匹配，相当于j 变成了k，模式串向右移动j - k位。
因为k 的值是可变的，所以我们用next[j]表示j处字符失配后，下一次匹配模式串应该跳到的位置。换言之，失配前是j，pj跟si失配时，用p[ next[j] ]继续跟si匹配，相当于j变成了next[j]，所以，j = next[j]，等价于把模式串向右移动j - next [j] 位。
而next[j]应该等于多少呢？next[j]的值由j 之前的模式串子串中有多大长度的相同前缀后缀所决定，如果j 之前的模式串子串中（不含j）有最大长度为k的相同前缀后缀，那么next [j] = k。

如之前的图所示：

回归到本文开始的问题，摘录July老师博客的解说：（原博客地址点击此处）
咱们来分析下KMP的时间复杂度。分析之前，先来回顾下KMP匹配算法的流程：

“KMP的算法流程：

假设现在文本串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] 位。”

我们发现如果某个字符匹配成功，模式串首字符的位置保持不动，仅仅是i++、j++；如果匹配失配，i 不变（即 i 不回溯），模式串会跳过匹配过的next [j]个字符。整个算法最坏的情况是，当模式串首字符位于i - j的位置时才匹配成功，算法结束。
所以，如果文本串的长度为n，模式串的长度为m，那么匹配过程的时间复杂度为O(n)，算上计算next的O(m)时间，KMP的整体时间复杂度为O(m + n)。