串的两种模式匹配方式（BF/KMP算法）

前言

串，又称做字符串，它是由0个或者多个字符所组成的有限序列，串一样能够采用顺序存储和链式存储两种方式进行存储，在主串中查找定位子串问题（模式匹配）是串中最重要的操做之一，而不一样的算法实现有着不一样的效率，咱们今天就来对比学习串的两种模式匹配方式：

• 朴素的模式匹配算法（Brute-Force算法，简称BF算法）

• KMP模式匹配算法

朴素的模式匹配算法（BF算法）

BF算法是模式匹配中的一种常规算法，它的思想就是：

• 第一轮：子串中的第一个字符与主串中的第一个字符进行比较
  • 若相等，则继续比较主串与子串的第二个字符
  • 若不相等，进行第二轮比较
• 第二轮：子串中的第一个字符与主串中第二个字符进行比较......
• 第N轮：依次比较下去，直到所有匹配

图示说明：

第一轮：

第二轮：

...... 原理一致，省略中间步骤

第五轮：

第六轮：

代码实现：

看完文字与图例讲解，咱们来动手实现一个这样的算法

简单概括上面的步骤就是：

主串的每个字符与子串的开头进行匹配，匹配成功则比较子串与主串的下一位是否匹配，匹配失败则比较子串与主串的下一位，很显然，咱们可使用两个指针来分别指向主串和子串的某个字符，来实现这样一种算法

匹配成功，返回子串在主串中第一次出现的位置，匹配失败返回 -1，子串是空串返回 0

int String::bfFind(const String &s, int pos) const {
    //主串和子串的指针，i主串，j子串
    int i, j;
    //主串比子串小，匹配失败，curLenght为串的长度
    if (curLength < s.curLenght)
        return -1;
    
    while (i < curLength && j < s.curLength) {
        //对应字符相等，指针后移
        if (data[i] == s.data[j])
            i+, j++;
       	else {	//对应字符不相等
            i = i -j + 1;	//主串指针移动
            j = 0; //子串从头开始
        }
        //返回子串在主串的位置
        if (j >= s.curLength) 
            return (i - s.curLength);
        else return -1;    
    }
}
复制代码

注：代码只为体现算法思路，具体定义未给出

这种算法简单易懂，却存在着一个很大的缺点，那就是须要屡次回溯，效率低下，若主串为 000000000001 子串为00001，这就意味着每一轮都要比较到子串的最后一个字符才会匹配失败，有没有更好的办法呢？下面的KMP模式匹配算法就很好的解决了这一问题

KMP模式匹配算法

若是仅仅进行一些少许数据的运算，可能你甚至以为BF算法也还行，起码是很容易写出来的，毕竟能跑的就是好程序，可是一旦数据量增大，你就会发现有一些 “无用功” 真的会大大的拖慢你的速度

KMP模式配算法是由 D.E.Knuth，J.H.Morris，V.R.Pratt 三位前辈提出的，它是一种对朴素模式匹配算法的改进，核心就是利用匹配失败后的信息，尽可能减小子主串的匹配次数，其体现就是 主串指针一直日后移动，子串指针回溯

图示说明：

下面所表示的是朴素模式匹配算法的过程，咱们看看若是使用KMP算法的思想，哪些步骤是能够省略掉的

① 中前五个元素，均互相匹配，知道第六个元素才匹配失败，按照BF算法来讲，就直接进行 ② ③ 操做，可是，咱们能够发现，子串中的前三个元素 a b c 均不是相同的，可是在 ① 中已经与 主串相匹配，因此 子串分别与主串中的第二 第三个元素匹配 必定是不匹配的，因此图中的 ② ③ 都可以省略

在 ① 中 子串中的 第一第二个元素 ab 和第四第五个元素 ab 是相同的，且 第四第五个元素 ab 已经与主串中的 第四第五个元素匹配成功，这意味着，子串中第一第二个元素 ab 必定与 主串中 第四第五个元素相匹配，因此 ④ ⑤ 步骤能够省略

若是按照这种思路，上面的例子只须要执行 ① 和 ⑥ 就能够了

next 数组值推导

(一) 主串指针是否须要回溯

咱们观察上面的两种过程 ，BF算法-①②③④⑤⑥，KMP算法-①⑥，若是咱们如今假定有两个指针，i 和 j，分别指向主串和子串中的所处位置，从上图咱们能够知道，主串指针，也就是 i 的值在 ① 的状态下， 指针指向6的位置，而在 ②③④⑤ 中却分别指向了2345，而在 ⑥ 中仍指向6的位置

这说明，朴素模式匹配算法，主串的 i 值会不断的进行回溯，可是 KMP模式匹配算法将这种不必的回溯省略掉了，因此减小了执行次数

(二) 子串指针优化总结

既然主串指针不进行回溯，那么还能够优化的就是 子串指针了，通常会遇到两种状况 咱们举两个例子：

• 若是子串为 abcdef，主串为abcdexabcdef，当第一轮匹配到第六个字符f和x的时候，匹配失败了，这个时候若是按照朴素模式匹配，就须要拿子串的首元素a去分别和主串的bcde进行比较，可是因为子串f元素前的元素中没有相同的元素，而且与主串匹配，因此a与主串中的2-5号元素 即 bcde 都是不可能相匹配的，全部这几部均可以省略，直接让a和主串中的x去匹配

• 若是子串为abcabx，主串为abcababcax，在第一轮中，前五个元素子主串分别相匹配，第六个元素位置出错，按照朴素模式匹配，咱们须要拿子串首元素a，依次与主串中的a后面的元素匹配，可是子串前面三个字符abc是不相等的，按照咱们第一种状况的经验，就直接跳过这些步骤了，全部咱们直接拿 子串a与 主串第四个元素a进行比较就能够了，可是咱们发现，子串中出错的位置x前的串 abcab 的前缀和后缀都是 ab，既然第一轮的时候，已经匹配成功，那就意味着，子串中的 第一第二个元素ab必定与 主串中 第四第五个元素 ab相等，因此这个步骤也能够省略，也就直接能够拿子串前缀ab后面的c开始于a进行比对，这也就是咱们上面图中例子的详细思路

总结：因此咱们得出规律，子串指针的值取决于，子串先后缀元素的类似程度

想要应用到具体代码中，咱们能够把子串位置变化 的 j 值定义成一个next数组，且长度与子串长度相同

• 状况1：当 j = 0 时，next[j] = -1, 表示子串指针指向下标为0的元素的时候匹配失败，子串没法回溯，(j不能赋值-1) ，此时将主串指针后移一位，子串不，进行下一轮比较

• 状况2：在已经匹配的子串中，存在相同的前缀串 T₀ T₁ ... T_k-1 和后缀串 T_j-k T_j-k+1 ... T_j-1，子串指针则回溯到next[j] = k的位置，而后进行下一趟比较，例如：子串 abcabc 有相同前缀和后缀ab 因此子串指针回溯到 c的位置

• 状况3：在已经匹配的子串，若不存在相等的前缀和后缀，则主串指针不动，子串指针回溯到 j = 0 的位置，而后进行下一趟比较

例：主串 S = “abc520abc520abcd”, 子串 T = "abc520abcd" ，利用 KMP算法匹配过程

子串 next 数组

j	0 1 2 3 4 5 6 7 8 9
子串	a b c 5 2 0 a b c d
next[j]	-1 0 0 0 0 0 0 1 2 3

能够看到，在 指针 i = 9 且 j = 9 的时候，匹配失败， 此时 next[9] = 3 ，因此子串指针回溯到 下标 j = 3 的位置也就是元素 5 的位置，进行第二轮比较，而后正好所有匹配成功

(三) 求next数组算法实现

void Stirng::getNext(const String &t, int *next) {
    int i = 0, j = -1;
    next[0] = -1;
    while (i < t.curLength - 1) {
        if ((j == -1) || t[i] == t[j]) {
            ++i, ++j;
            next[i] = j;
        }else{
            j = next[j];
        }
    }
}
复制代码

KMP算法代码实现

有了 next 数组的铺垫，咱们就能够来实现KMP算法了

匹配成功返回子串在主串中第一次出现的位置，失败返回-1，子串为空串返回0

int String::kmpFind(const String &t, int pos) {
    //不容许申请大小为0的数组
    if (t,curLength == 0) return 0;
    //若是主串比子串小，匹配失败
    if(t.curLength < t.curLength) return -1;
    //主串指针i，子串指针j
    int i = 0, j = 0;
    int *next = new int[t.curLrngth];
    getNext(t,next);
    while (i < curLength && j < t,curLength) {
        if (j == -1 || data[i] == t.data[j])	//状况12
            i++, j++;
   		else	//状况3
           	j = next[j];
    }
    delete []next;
    if (j > t.curLength)
        return (i - t.curLength)
    else
        return -1;
}
复制代码

KMP模式匹配算法改进

有一种特殊状况的出现，使得咱们不得不考虑KMP算法的改进

那就是子串中有多个连续重复的元素，例如主串 S=“aaabcde” 子串T=“aaaaax” 在主串指针不动，移动子串指针比较这些值，其实有不少无用功，由于子串中前5个元素都是相同的a，因此咱们能够省略掉这些重复的步骤

void String::getNextVal(const String &t, int *nextVal) {
    int i = 0, j = -1;
    nextVal[0] = -1;
    while (i < t.curLength -1) {
        if ((k == -1) || (t[i] == t[j])) {
            ++i, ++j;
            if (t[i] != t[j])
                nextVal[i] = j;
            else
                nextVal[i] = nextVal[j];
        }
        else 
            j = nextVal[j];
    }
}
复制代码

这种改进的核心就在于 增长了对子串中 t[i] 和 t[j] 是否相等的判断，相等则直接将 nextVal[j] 的值赋给 nextVal[i]

总结

在BF算法中，当主串和子串不匹配的时候，主串和子串你的指针都须要回溯，因此致使了该算法时间复杂度比较高为 O(nm) ，空间复杂度为 O(1) 注：虽然其时间复杂度为 O(nm) 可是在通常应用下执行，其执行时间近似 O(n+m) 因此仍被使用

KMP算法，利用子串的结构类似性，设计next数组，在此之上达到了主串不回溯的效果，大大减小了比较次数，可是相对应的却牺牲了存储空间，KMP算法 时间复杂度为 O(n+m) 空间复杂度为 O(n)

结尾：

若是文章中有什么不足，或者错误的地方，欢迎你们留言分享想法，感谢朋友们的支持！

若是能帮到你的话，那就来关注我吧！若是您更喜欢微信文章的阅读方式，能够关注个人公众号

在这里的咱们素不相识，却都在为了本身的梦而努力 ❤

一个坚持推送原创开发技术文章的公众号：理想二旬不止