字符串模式匹配算法--BF和KMP详解

1,问题描述

字符串模式匹配：串的模式匹配，是求第一个字符串（模式串:str2）在第二个字符串（主串:str1）中的起始位置。

注意区分：

子串：要求连续（如：abc 是abcdef的子串）
子序列：可以不连续（如：acd是abcdef的子序列）

2,简单字符串模式匹配(BF算法)

2.1 简单匹配思路描述

简单字符串模式匹配算法，也就是了BF（Brute Force 蛮力，暴力）算法，俗称暴力法。

基本思路：

- (1) 从主串S指定的字符开始（一般为第1个）和模式串P的第一个字符比较，若相等，则继续逐个比较后续字符，直到P中的每个字符依次和S中的一个连续字符序列相等，则称匹配成功；

- (2)如果比较过程中有某对字符串不相等，则从主串S的下一个字符起再重新和T的第一个字符比较。如果S中的字符都比完了仍然没有匹配成功，则称匹配不成功。

简单模式匹配算法--举例：

主串str1:    a b a b c a b c a c b a b

模式串str2:  a b c a c

          (i=0

第一趟匹配：a b a b c a b c a c b a b

          a b c

              (j=2

             (i=1

第二趟匹配:  a b a b c a b c a c b a b

             a

             (j=0

               (i=2

第三趟匹配： a b a b c a b c a c b a b

               a b c a c

                       (j=4

                (i=3

第四趟匹配：a b a b c a b c a c b a b

                a

                (j=0

                  (i=4

第五趟匹配：a b a b c a b c a c b a b

                  a

                  (j=0

                    (i=5      (i=10

第六趟匹配：a b a b c a b c a c b a b

                    a b c a c

                    (j=0      (j=5

2.2 时间复杂度

设串S和P的长度分别为m,n，则它在最坏情况下的时间复杂度是O(m*n)。BF算法的最坏时间复杂度虽然不好，但它易于理解和编程，在实际应用中，一般还能达到近似于O(m+n)的时间度（最坏情况不是那么容易出现的），因此，还在被大量使用。

2.3 BF代码实现

#include <iostream>

#include <vector>

using namespace std;

int BF_strMatch(vector<char> v1, vector<char> v2) {

    //v1是主串，v2是模式串

    //如果匹配成功，返回子串在主串中的起始位置；否则，返回-1；

    int i = , j = ;

    int n = v1.size(), m = v2.size();

    while (i < n && j < m) {

        if (v1[i] == v2[j]) {

            ++i;

            ++j;

        }

        else {

            i = i - j + ;//通过观察下标变换的关系得出

            j = ;

        }

    }

    return (j == m) ? (i - m) : -;

}

void main() {

    vector<char> s1 = { 'a','b','a','b','c','a','b','c','a','c','b','a','b'};

    vector<char> s2 = { 'a','b','c','a','c' };

    cout << BF_strMatch(s1, s2) << endl;

}

3,经典KMP匹配算法

3.1 KMP算法基本思想

KMP算法可以在O(n+m)的时间数量级上完成串的模式匹配操作。其改进在于：每当一趟匹配过程中出现字符比较不等时，不需回溯 i 指针( i 只增不减)，而是利用已经得到的“部分匹配”的结果将模式串向右滑动尽可能远一段距离后，继续进行比较。

3.2 KMP算法关键点

KMP算法加速原因：让前面匹配过的信息指导后面。

KMP算法理解的关键点：

1.求解最长公共子串（next数组），只跟模式串 str2 有关，而与主串 str1 无关（有的参考书没有讲解清楚这一点，导致容易混淆）；
2.最长公共子串，大多数的参考书称为最长公共前缀，这里我称之为最长公共子串，是为了避免与下面两个概念混淆。这里对最长公共子串的定义：最长前缀和最长后缀的最长公共子串。

最长前缀：从第一个字符的起的连续一串字符，不含最后一个字符；
最长后缀：不含第一个字符，从中间某一个字符其到最后一个字符的连续一串字符；

例1：对于模式串“a b c a b c d”,求字符d的最长公共子串。

解：设length为字符d最长公共子串的长度，根据定义，length的可能取值为1~5：

                   a b c a b c d

length = 1 : a != c

length = 2 : ab != bc

length = 3 : abc == abc

length = 4 : abca != cabc

length = 5 : abcab != bcabc

显然，字符d的最长公共子串的长度为3

例2：对于模式串“a a a a a b”,求字符b的最长公共子串。

同理，length可能的取值为1~4：

length = 1 : a == a

length = 2 : aa == aa

length = 3 : aaa == aaa

length = 4 : aaaa == aaaa

显然，字符b的最长公共子串的长度为4

3.3 求解next数组

next数组的求解，实际是对每个位置找到最长的公共子串：

一般地，对于模式串str2="P₀P₁P₂…P_m-1"，长度为m，其next数组的定义：

当j=0时，即str2中的第一个字符，其前没有字符，人为规定 next[0] = -1;
当j=1时，即str2中的第二字符，其前只有一个字符，人为规定 next[1] = 0;
当 2<= j =< m-1:
- Max{ k | 1<= k =< j-1 且 “P₀…P_k-1” == "P_j-k…P_j-1"}不空时，next[j] = Max{ k | 1<= k =< j-1 且 “P₀…P_k-1” == "P_j-k…P_j-1"}，
- Max{ k | 1<= k =< j-1 且 “P₀…P_k-1” == "P_j-k…P_j-1"}为空时，next[j] = 0 ;

求解next数组的代码：

vector<int> getNext(vector<char> v) {

    //模式串str2 与 模式串str2 (自己跟自己) 做KMP匹配

    int m = v.size();//v字符串长度

    vector<int> next(m, );

    int i = ;

    int j = ;

    if (m == ) return next;

    next[] = -;

    if (m == ) return next;

    next[] = ;

    while (i < m) {

        if (v[i - ] == v[j]) {

            ++j;

            next[i] = j;

            ++i;

        }

        else if(j>){

            j = next[j];

        }

        else {

            next[i++] = ;

        }

    }

    return next;//放对位置

}

//test

void main() {

    vector<char> s3 = { 'a','b','a','a','b','c','a','c' };

    for (auto c : getNext(s3)) {

        cout << c << " ";

    }

    cout << endl;

}

求解next数组的经典方法（最好理解记住）：

 # 获取next[]数组

        def getNext(str):

            next = [-1]*len(str) # next[0]=-1

            if len(str)>=1:

                next[1] = 0

            i, j =1, 0

            while(i<len(str)-1):

                if j==-1 or str[i]==str[j]:

                    i += 1

                    j += 1

                    next[i] = j

                else:

                    next[i] = next[j]

            return next

3.4 完整的KMP算法代码

#include <iostream>

#include <vector>

using namespace std;

int KMP_strMatch(vector<char> v1, vector<char> v2,vector<int> next) {

    //v1是主串，v2是模式串

    //如果匹配成功，返回子串在主串中的起始位置；否则，返回-1；

    int i = , j = ;

    int n = v1.size(), m = v2.size();

    while (i < n && j < m) {

        if (v1[i] == v2[j]) {

            ++i;

            ++j;

        }

        else {

            if (j == ) ++i; //j回到模式串头部还不匹配，i加1

            j = next[j];       //使用next数组提供指导

        }

    }

    return (j == m) ? (i - m) : -;

}

vector<int> getNext(vector<char> v) {

    //模式串str2 与 模式串str2 (自己跟自己) 做KMP匹配

    int m = v.size();//v字符串长度

    vector<int> next(m, );

    int i = ;

    int j = ;

    if (m == ) return next;

    next[] = -;

    if (m == ) return next;

    next[] = ;

    while (i < m) {

        if (v[i - ] == v[j]) {

            ++j;

            next[i] = j;

            ++i;

        }

        else if(j>){

            j = next[j];

        }

        else {

            next[i++] = ;

        }

    }

    return next;//放对位置

}

void main() {

    vector<char> s1 = { 'a','b','a','b','c','a','b','c','a','c','b','a','b'};

    vector<char> s2 = { 'a','b','c','a','c' };

    for (auto c : getNext(s2)) {

        cout << c << " ";

    }

    cout << endl;

    cout << KMP_strMatch(s1, s2,getNext(s2)) << endl;

}

4,KMP算法进深理解

4.1 BF和KMP执行流程对比

当str1[i] == str2[j]时，操作一样，++i，++j;
当str1[i] != str2[j]，即不匹配时：
- BF：i = i - j + 2, j = 0;
- KMP：i 不动(不回溯)，j = next[j];

4.2 next数组要求最大公共子串的原因

str1:a b k a b a b k a b x

str2:a b k a b a b k a b y                      //i=10,j=10 不匹配，j=next[10]=5（不是j=0，减少了5次比较）,继续比较

               a b k a b a b k a b F            //i=10,j=5 不匹配，j=next[5]=2（不是j=0，减少了2次比较）,继续比较
                     a b k a b a b k a b F      //i=10,j=2 不匹配，j=next[2]=0（才是j=0，较少了0次比较）,继续比较
                         a b k a b a b k a b F  //i=10,j=0 不匹配，++i（此时i才加1）,j=0

分析：
（1）加速的原因：减少了不必要的比较次数。
（2）为什么模式串可以向右滑动尽可能远一段距离后，再继续比较：

正如上面的例子：前面都是相等的，到了x与y匹配时才不相等——
       (W--------------Q)
[i|-----k---|j          |x]      //红色部分是滑过的距离，即不必要的比较次数,这里指的i……j之间的位置不可能匹配出str2
(-a-b-k-a-b)(-a-b-k-a-b)

(W--------------Q)
(-a-b-k-a-b)(-a-b-k-a-b)
[0|         |j          |y]

假设从k字符起可以配出str2，那么必然会存在更长的子串（W-------Q）比y位置的最长子串（a-b-k-a-b）更长，如果next数组求解正确，这是不可能。出现矛盾，假设不成立。
因为next数组求的就是每一个字符的最长公共子串。

参考资料：

1.《数据结构考研复习指导》--王道单科书

2.https://www.cnblogs.com/zzqcn/p/3508442.html#_labelTop 字符串模式匹配算法1 - BF和KMP算法

3. https://www.nowcoder.com/courses/semester/senior 《牛客高级项目课——（牛客网）》--大牛·左程云