字符串匹配之BF与KMP算法

数据结构之字符串匹配算法(BF算法和KMP算法) 字符串匹配算法: 就是给定两个串,主串(s)和子串(sub), 查找子串是否在主串里面,如果找到便返回子串在主串中第一个元素的位置下标,否贼返回-1,。 在这里我 们讨论的时候主要用字符串来举例实现。 总共有两个算法,分别为BF算法和它的优化算法KMP算法。 首先我们来讲一下BF算法,BF 算 法 即 朴 素 算 法 :它 的 实 现 方 式 是 这 样 的 , 假 定 我 们 给 出 字 ... 阅读详情

字符串模式匹配

字符串模式匹配的描述:有两个字符串 T 和 p,若想要在串 T 中查找是否有与串 p 相等的的字串,称串 T 为目标串,串 p 为模式串,并称查找模式串 p 在目标串 T 的匹配位置的运算为模式匹配。

比如有如下两个字符串:

目标串T: abaabcac
模式串p: ab

我们可以看到,模式串 p 的匹配结果会出现两次,分别是从 T[0] 和 T[3] 开始。

字符串匹配是一项非常频繁的任务。例如,有一份名单,你急切地想知道自己在不在名单上;又如,假设你拿到了一份文献,你希望快速的找到某个关键字所在的章节。接下开先最朴素的 B-F 算法说起。

B-F算法

顾名思义,BF算法是由 Brute 和 Force 提出来的,所以被称为 B-F 算法。

其算法思想是:用模式串 p 的字符依次与 目标串 T 中的字符比较。如果比较成功,返回模式串 p 第 0 个字符 p[0] 在目标串中相匹配的位置;如果在其中某个位置 i 出现 p[i] 不等于 T[i],这时候可以将模式串 p 右移一位,且模式串 p 需要从头开始与 T 中字符依次比较。如此反复执行,直到出现以下两种情况之一,就可以结束算法:

第一种情况是:执行到某一趟,模式串的所有字符都与目标串对应的字符串对应字符相等,则匹配成功。

第二种情况是:模式串 p 已经移动到最后可能与目标串 T 比较的位置,但不是每一个字符都能与 T 匹配,则匹配失败,返回 -1。

接下来看一个实例:

假设有目标串 T 和模式串 p:
===========================
a. 先来看一下匹配成功的过程
第一趟:
T: a b b a b a
   | | x
p: a b a
第二趟:
T: a b b a b a
     x
p:   a b a
第三趟:
T: a b b a b a
       x
p:     a b a
第四趟:
T: a b b a b a
         | | |
p:       a b a
===========================
b. 再看匹配不成功的过程
第一趟:
T: a b b a b a
   | x
p: a a a
第二趟:
T: a b b a b a
     x
p:   a a a
第三趟:
T: a b b a b a
       x  
p:     a a a
第四趟:
T: a b b a b a
         | x
p:       a a a

下面是 B-F 算法算法的实现:

//目标串为T,模式串为p,从目标串的下标为k开始匹配
int BruteForce(const char *T, const char *p, int k)
{
    int i = 0;
    int j = 0;
    int len_T = strlen(T);
    int len_p = strlen(p);
    for (i = k; i <= len_T - len_p; ++i) //逐趟比较
    {
        for (j = 0; j < len_p; ++j)
        {
            if (T[i + j] != p[j]) //从目标串下标为i的开始与模式串逐个比较
                break;
        }
        if (j == len_p) //模式串扫描完,匹配成功
            return i;
    }
    return -1; //匹配失败
}

算法分析:

在 B-F 算法中,一旦比较不相等,就将模式串 p 右移一位,再从模式串 p[0] 开始逐个比较,若目标串 T 的长度为 n,模式串 P 的长度为 m,看出第一趟比较失败,需要比较次数 m 次,最坏情况下如果一直失败,最大需要 n -m -1 趟,每趟比较都在最后出现不相等,要做 m 次比较,总的比较次数为 (n - m + 1) * m,因为多数场合下 m 远远小于 n,所以 B-F 的算法时间复杂度为 O(nm)。

B-F 算法的改进思考

在分析上面的程序可知,B-F 算法慢的原因就是每趟比较失败需要回溯到模式串 p[0] 重新逐个比较,然而回溯是可以避免的,我们还是依上面的实例 a 为例:

a. 先来看一下匹配成功的过程
第一趟:
T: a b b a b a
   | | x
p: a b a
第二趟:
T: a b b a b a
     x
p:   a b a
第三趟:
T: a b b a b a
       x
p:     a b a
第四趟:
T: a b b a b a
         | | |
p:       a b a

从第一趟来看:

T[0] = p[0],T[1] = p[1],T[2] ≠ p[2],所以模式串 p 需要右移一位重新从头开始逐个比较,但是 p[0] ≠ p[1],由此可推导 T[1](=p[1]) ≠ p[0] ,我们右移一位比较肯定是不相等的,这一趟是否可以不比较直接跳过?

由于 p[0] = p[2],所以 T[2] ≠ p[0](=p[2]) ,再将模式串 p 右移一位,用 T[2] 和 p[0] 比较也不会相等。我们应当将 p 直接右移 3 位,跳过第二趟和第三趟,直接执行第四趟,也就是用 T[3] 和 p[0] 开始进行比较。而这样的过程就消除了每趟的回溯。

这种处理的思想是由 Knuth、Morris、Pratt 同时提出的,所以称为 KMP 算法,后面我们将会介绍 KMP 算法。

KMP 算法

kmp 的优化思想

下面我们讨论一般的情形,假设:

目标串: T = { T[0], T[1], ... , T[n-1] };

模式串: p = { p[0], p[1], ..., p[m-1] };

如果用朴素模式 B-F 算法做第 s 趟比较时,从目标串 T 的第 s 个位置 T[s] 与 模式串 p 的第 0 个位置 p[0] 开始进行比较,直到在目标串的 T[s + j] 位置失配了:

目标串T:T[0]  T[1] ... T[s-1]  T[s]  T[s+1]  T[s+2] ... T[s+j-1]  T[s+j]  ...  T[n-1]
                                |      |       |           |        x
模式串p:                       p[0]   p[1]    p[2]  ...  p[j-1]    p[j]

这时候,就有:

T[s], T[s+1], T[s+2], ..., T[s+j-1] = p[0], p[1], p[2], ..., p[j-1] ①

继续按朴素模式 B-F 算法,那么下一趟应该从目标 T 的第 s+1 的位置开始用 T[s+1] 与模式串 p 的 p[0] 位置对齐,重新开始比较,如果我们想要继续匹配成功,那么必须满足:

T[s+1], T[s+2], ..., T[s+j], ..., T[s+m] = p[0], p[1], ..., p[j-1], ..., p[m-1]

同时在模式串 p 中,如果:

p[0], p[1], ..., p[j-2] ≠ p[1], p[2], ..., p[j-1] ②

则第 s+1 趟即使不用进行比较,也能断定必然失配。

由上面的推论 ① 和推论 ② 可以得到:

p[0], p[1], ..., p[j-2] ≠ T[s+1], T[s+2], ..., T[s+j-1] (= p[1], p[2], ..., p[j-1])

既然第 s+1 趟可以不做,那么 s+2 趟又怎样的?由上面的推理可知:

在 s+2 趟中,如果:

p[0], p[1], ..., p[j-3] ≠ p[2], p[3], ..., p[j-1]

那么仍然有:

p[0], p[1], ..., p[j-3] ≠ T[s+2], T[s+3], ..., T[s+j+1] (= p[2], p[3], ..., p[j-1])

那么这一趟比较仍然会失配。

以此类推,直到对于某一个值 k,使得:

p[0], p[1], ..., p[k+1] ≠ p[j-k-2], p[j-k-1], ..., p[j-1]

且:

p[0], p[1], ..., p[k] = p[j-k-1], p[j-k], ..., p[j-1]

才会有:

p[0], p[1], ..., p[k] = T[s+j-k-1], T[s+j-k], ..., T[s+j-1]
                             |          |              | 
                         p[j-k-1],   p[j-k],  ...,   p[j-1]

然后我们可以把第 s 趟比较失配的模式串 p 从当前位置直接向右滑动 j-k-1 位,这时候因为目标串 T 中 T[s+j] 之前已经与模式串 p 中 p[j] 之前的字符匹配过了,所以可以直接从目标串 T 中的 T[s+j] (即上一趟失配的位置) 与模式串 p 的 p[k+1] 开始,继续向下进行匹配比较。

在 KMP 算法中,目标串 T 在第 s 趟比较失配时,扫描指针 s 不必回溯,算法下一趟继续从此处开始向下进行匹配比较,而在模式串 p 中扫描指针应该回退到 p[k+1] 位置。

next 数组

上面上面所说的 k 的确定方法,对于不同的 j,k 的取值不同,它仅仅依赖于模式串p 本身前 j 个字符的构成,与目标串 T 无关。

我们可以使用一个 next 特性函数:当模式串 p 中的 p[j] 字符与目标串 T 中相应字符失配时,模式串 p 中应当由哪个字符(设为 p[k+1])与目标中刚失配的字符重新继续进行比较。

设模式串 p = p[0], p[1], ..., p[m-2], p[m-1],则它们的 next 特征函数定义如下:

          |-1,    当 j = 0
next(j) = |k + 1, 当 0 ≤ k < j-1, 且使得 p[0], p[1], ..., p[k] = p[j-k-1], p[j-k], ..., p[j-1] 的最大整数
          |0,     其他情况

我们称 p[0], p[1], ..., p[k] 为串 p[0], p[1], ..., p[j-1] 的前缀子串,p[j-k-1], p[j-k], ..., p[j-1] 为串 p[0], p[1], ..., p[j-1] 的后缀子串,它们都是原串的真子串。

如下实例:

假如模式串 p = “abaabcac”,对应的 next 函数如下所示:

   下标j:   0   1   2   3   4   5   6   7
 模式串p:   a   b   a   a   b   c   a   c
next(j):  -1   0   0   1   1   2   0   1

过程如下:

当 j = 0 时,next[j] = -1。表示下一趟匹配比较时,模式串的第 -1 个字符与目标串上次失配的位置对其,也就是模式串的起始位置 p[0] 与目标串上次失配的位置的下一个位置对其,继续向后做匹配比较。

当 j = 1 时,满足 0 ≤ k < j-1 的情况找不到,所以 next[j] = 0 (按其他情况),表示下一趟匹配比较时,模式串 p 的第 0 个字符 p[0] 与目标串上次失配的位置对其向后继续比较。

当 j = 2 时,k 的取值可以是 0,因为 p[0] ≠ p[1],所以 next(j) = 0,表示下一趟匹配比较时,模式串 p 的第 0 个字符 p[0] 与目标串上次失配的位置对其向后继续比较。

当 j = 3 时,k 的取值可以是 0 和 1,因为 p[0] = p[2] 且 p[0], p[1] ≠ p[1]p[2],故 k 取 0,next(j) = k +1 = 1。表示下一趟匹配比较时,模式串 p 的第 1 个字符 p[1] 与目标串上次失配的位置对其向后继续比较。

当 j = 4 时,情况和 j = 3 类似。

当 j = 5 时,k 可以取 0 到 3 的值,因为 p[0] ≠ p[4],p[0], p[1] = p[3], p[4],此外 p[0], p[1], p[2] ≠ p[2], p[3], p[4],且 p[0], p[1], p[2], p[3] ≠ p[1], p[2], p[3], p[4],因此 k = 1,next(j) = k+1 = 2。表示下一趟匹配比较时,模式串 p 的第 2 个字符 p[2] 与目标串上次失配的位置对其向后继续比较。此时,模式串 p 右移,p[0], p[1] 覆盖到原来的 p[3], p[4] 的位置,从 p[3] 开始继续向后进行对应字符的比较。

其他情况依次类推。

一般的,假如在进行某一趟匹配时,在模式串 p 的第 j 位失配,如果 j > 0,那么在下一趟比较时模式串 p 的起始比较位置是 pnext(j),目标串 T 的指针不回溯,仍指向上一趟失配的字符;如果 j = 0,则目标串 T 指针进 1,模式串 p 指针回到 p[0],继续进行下一趟匹配比较。这也就是 KMP 算法的核心思想。

next 数组实现

上面说了很多,如何正确的计算出特征函数 next(j) 才是实现 KMP 算法的关键。

从上面的 next(j) 的定义出发,计算 next(j) 就是要在模式串 p[0], p[1], p[2], ..., p[j-1] 中找出最长的相等的前缀子串 p[0], p[1], ..., p[k] 和后缀子串 p[j-k-1], p[j-k], ..., p[j-1]。

我们可以使用递推的方法求 next(j) 的值。

假设已有 next(j) = k,则有:

0 ≤ k < j-1 且 p[0], p[1], ..., p[k] = p[j-k-1], p[j-k], ..., p[j-1] ③

若设 next(j+1) = max{ k+1 | 0 ≤ k+1 < j},使得 p[0], p[1], ..., p[k+1] = p[j-k-1], p[j-k], ..., p[j] ④

如果 p[k+1] = p[j],则由 ④ 可知:next(j+1) = next(j) + 1。

如果 p[k+1] ≠ p[j] ,则由 ③ 出发,在 p[0], p[1], …, p[k] 中寻找使得 p[0], p[1], ..., p[h] = p[k-h], p[k-h+1], ..., p[k] 的 h。 ⑤

这时候存在两种情况:

情况1:找到 h:

由 next(k) 的定义知:next(k) = h。综合 ⑤ 和 ③,就有:

p[0], p[1], ..., p[h] = p [k-h], p[k-h+1], ..., p[k] = p[j-h-1], p[j-h], ..., p[j-1]

即在 p[0], p[1], ..., p[j-1] 中找到了长度位 h + 1 的相等的前缀子串和后缀子串。

这是如果 p[h+1] = p[j],则由 next(j+1) 的定义:

next(j+1) = h +1 = next(k) + 1 = next(next(j)) + 1

如果 p[h+1] ≠ p[j],则在 p[0], p[1], ..., p[h] 中寻找更小的 next(h) = 1。如此递推下去,可能还需要以同样的方式缩小寻找范围,直到 next(k) = -1 为止。

情况2:找不到h,这时候 next(k) = -1。

通过以上分析,可以给出下面的计算 next(j) 的 getNext 算法代码:

//通过模式串p获得next数组
void getNext(char *p, int *next)
{
    int j = 0;
    int k = -1;
    int len_p = strlen(p);
    next[0] = -1;
    while (j < len_p)
    {
        if (k == -1 || p[j] == p[k])
        {
            ++j;
            ++k;
            next[j] = k;
        }
        else
        {
            k = next[k];
        }
    }
}

该函数的时间复杂度为 O(len_p)。

kmp 算法的实现

上面已经知道了 next 数组的实现,则 KMP 算法的实现就不难了。一般的,假如在进行某一趟匹配时,在模式串 p 的第 j 位失配,如果 j > 0,那么在下一趟比较时模式串 p 的起始比较位置是 pnext(j),目标串 T 的指针不回溯,仍指向上一趟失配的字符;如果 j = 0,则目标串 T 指针进 1,模式串 p 指针回到 p[0],继续进行下一趟匹配比较。

下面是 KMP 算法完整实现:

const int MAX_NEXT = 100;
int next[MAX_NEXT] = {0};

//通过模式串p获得next数组
void getNext(char *p, int *next)
{
    int j = 0;
    int k = -1;
    int len_p = strlen(p);
    next[0] = -1;
    while (j < len_p)
    {
        if (k == -1 || p[j] == p[k])
        {
            ++j;
            ++k;
            next[j] = k;
        }
        else
        {
            k = next[k];
        }
    }
}

//目标串T, 模式串p, 从目标串T的下标为k开始匹配
int KMP(const char *T, const char *p, int k)
{
    int i = k;
    int j = 0;
    int len_T = strlen(T);
    int len_p = strlen(p);

    while ((i < len_T) && (j < len_p))
    {
        if (j == -1 || T[i] == p[j])
        {
            ++i;
            ++j;
        }
        else
        {
            //这里就是BF和KMP的最大区别
            //i = i - j + 1; j = 0; //BF算法如果匹配失败,模式串p需要从头开始
            j = next[j]; //KMP算法是取模式串p的next值对应的下标继续下一次匹配
        }
    }
    if (j == len_p)
        return i - len_p;
    else
        return 0;
}

KMP 算法的时间复杂度取决于 while 循环,由于是无回溯算法,目标字符串比较有进无退,要么执行 posT 和 posP 进 1,要么查找 next[] 数组进行模式位置的右移,然后继续向后比较。最多比较次数为 O(lengthT),不超过目标串的长度。

下面给出一个实例:

=================================================
第1趟:
          ↓
目标串T: a c a b a a b a a b c a c a a b c
        | x
模式串p: a b a a b c a c
注:posT = 1, next[1] = 0,下一趟posT不变,posP = 0
=================================================
第2趟:
          ↓
目标串T: a c a b a a b a a b c a c a a b c
          x
模式串p:   a b a a b c a c
注:posP = 0, next[0] = -1, 下一趟 posT++, posP=0
=================================================
第3趟:
            ↓
目标串T: a c a b a a b a a b c a c a a b c
            | | | | | x
模式串p:     a b a a b c a c
注:posP = 5, next[5] = 2, 下一趟 posT 不变, posP=2
=================================================
第4趟:
                      ↓
目标串T: a c a b a a b a a b c a c a a b c
                  | | | | | | | |
模式串p:           a b a a b c a c
注:posP = 8, PosT - lengthP = 5

通过上面的对 KMP 算法的描述与推理以及实例,将会对于 KMP 算法有更深刻的认识。

字符串模式匹配的BF算法与KMP算法 设有主串s和子串t,子串t定位是指在主串s中找到一个与子串t相等的子串。通常把主串s称为目标串,把子串t称为模式串,因此定位也称作模式匹配。模式匹配成功是指在目标串s中找到一个模式串t。         传统的字符串模式匹配算法(也就是BF算法)就是对于主串和模式串双双自左向右,一个一个字符比较,如果不匹配,主串和模式串的位置指针都要回溯。这样的算法时间复杂度为O(n*m),其中n和m分别为串s 阅读详情

相关推荐

字符串匹配算法综述:BF、RK、KMP、BM、Sunday

字符串匹配算法综述:BF、RK、KMP、BM、Sunday

石沉溪洞 5670

KMP算法

KMP算法,next数组,nextval数组

m0_63282219的博客 874

字符串匹配(BF,BM,Sunday,KMP算法解析)

字符串匹配一直是计算机领域热门的研究问题之一,多种算法层出不穷。字符串匹配算法有着很强的实用价值,应用于信息搜索,拼写检查,生物信息学等多个领域。 今天介绍几种比较有名的算法: 1. BF 2. BM 3. Sunday 4. KMP—,BF算法 BF(Brute Force)算法又称为暴力匹配算法,是普通模式匹配算法。其算法思想很简单,从主串S的第pos个字符开

染尘 1万+

字符串的模式匹配--BF算法&KMP算法

BF算法是基于主串指针回溯,重新与子串进行逐字符进行比较,主串为S什么要进行回溯呢,原因在于模式P中存在相同的字符或者说由字符(串)存在重复(模式的部分匹配性质),设想如果模式P中字符各不相同,主串就S的指针就根本不需要回溯;然而,我们可以发现在主串S与模式发生失配时,主串指针进行回溯会影响效率,因为由于模式S本身字符的部分部分匹配性质,回溯之后,主串S与模式T有些部分比较是没有必要的,这就是对BF

Death Note 9679

字符串匹配(BF算法 +KMP算法)

BF算法,又称Brute Force暴力算法,从主串S的第一个字符开始和模式T的第一个字符进行比较,若相等,则继续比较两者的后续宇符;否则,从主串S的第二个宇符开始和模式T的第一个字符进行比较,重复上述过程,直到T中的字符全部比较完毕,则说明本趟匹配成功;或S中字符全部比较完,则说明匹配失败。可以参考下下图:(参考懒猫老师《数据结构》相关课程笔记) 即每一次匹配失败以后,指向主串的i向后移动一位,而指向模式串T的j总是回到串首,重新进行判断(这里我用了两种有些区别的方法实现了BF算法) KMP算法:....

m0_63223213的博客 1602

字符串匹配算法——BF、KMP原理及实现

任务说明 给定主字符串S=“字符串匹配算法——BF、KMP原理及实现”,我想知道S内是否包含副字符串T=“匹配算法”,并返回T的第一个元素“匹”在S内的位置。我们通常把主字符串称为目标串,将副字符串称为模式串。 本文主要利用BF算法以及KMP算法解决字符串匹配任务。 一、BF算法 首先,给定 “目标串” 和 “模式串” 如下: 1.算法概述 BF算法的整体思路就是遍历,是一种穷举法的体现。从目标串S的的第一个字符起与模式串T的第一个字符比较。 若相等,则继续对字符进行后续的比较;否则主串从第二个字符起与模

qq_41658995的博客 957

BF算法及KMP算法

一.BF算法 1.原理 暴力查找 逐个匹配主串字符,然后模式串j值回溯到1重新匹配 2.代码实现 二.KMP算法 1.原理 核心是避免不必要的回溯 问题是由模式串决定,不是目标串决定 只需要将j值模式串中j的位置回溯到next[j]位,而免除了前面不需要的匹配,以此来换取时间 2.难点拆解 ①前后缀 ②推导next数组 next数组:当模式匹配T失败时,next数组对应的元素指导应该用T串的哪个元素进行下一轮的匹配 利用已经部分匹配这个有效信息,保持i指针不回溯,通过修改j指针,让模式串尽量地移动到有效

triggerV的博客 1798

一篇文章带你通关BF算法与KMP算法

对于两个字符串,在主串中s中查找是否存在某一个子串t(一个串中任意个连续字符组成的子序列(包含空串)称为该串的子串),如果存在则返回串t在串s中第一次出现的位置。串s为主串,子串t成为模式串,这个过程也称为模式匹配*,下面来详细介绍下串的两种模式匹配算法:BF算法和KMP算法 1.BF算法 BF算法也称暴力匹配算法或有回溯的匹配算法,具体步骤为: 从主串s的第一个字符开始与t的第一个字符做比较 如果相等,继续逐个比较后续的字符 如果不相等,使主串的第二个字符与t的第一个字符比较 如果相等,继续逐个比较后续

qq_46213710的博客 1269

从BF算法到kmp算法详解

正文索引 一、KMP介绍 二、例子:子串匹配母串 1.BF算法的解决方法 三、kmp算法的实现 (1)为什么已经有BF算法了还要有KMP算法呢? (2)发明的算法基本思想 (3)具体实现 一、KMP介绍 KMP算法是一种改进的字符串匹配算法(有BF算法改进而来,BF算法是暴利搜索匹配的方式,而KMP则是对BF算法的回溯过程进行改进,从而大幅度降低了时间复杂度),能够很好地处理子串与母串的匹配 二...

与恶龙缠斗良久终成恶龙 411

MacTeX+TeXstudio:Macbook配置本地Latex看这一篇就够了

这个博客记录本人在MacBook上配置本地Latex的流程,其中选择的编译环境为MacTeX,编辑器为TeXstudio。采用的原因主要两点:一个是本人配置的原因主要是用来撰写毕业论文,希望能够尽可能简化设置流程,专注内容表达;第二是由于本人还有一个windows系统的笔记本,想要编辑器在专注写作体验的同时在两个系统上能够都适配,从而减少切换效率,故选择此组合。这篇文章介绍并详细记录了本人的安装流程,有相同需求的同志也可借鉴。

Katherine-XY的博客 6988

EM算法求解混合伯努利模型

本文记录了EM算法求解混合伯努利分布的推导,并提供了matlab实验代码。

霁月难逢 彩云易散 6974

《C语言》字符串匹配(BF算法+KMP算法)

字符串匹配 【问题描述】 对于字符串S和T,若T是S子串,返回T在S中的位置(T的首字符在S中对应的下标),否则返回-1. 【问题求解】 采用直接穷举法求解,称为BF算法。该算法从S的每一个字符开始查找,看T是否会出现。例如,S=“aababcde”,T=“abcd”: ...

MJ980629的博客 1万+

分享6款文字语音生成驱动虚拟数字人说话的开源项目

对定性和定量结果的大量实验表明,我们的算法实现了高质量的照片真实感对话头部视频,包括根据语音节奏进行的各种面部表情和头部运动,并超过了最先进的水平。我们的系统包含三个阶段。当然,FACEGOOD Audio2face 部分也可根据自己的喜好进行重新训练,比如你想用自己的声音或其它类型的声音,或者不同于 FACEGOOD 使用的模型绑定作为驱动数据,都可以根据下面提到的流程完成自己专属的动画驱动算法模型训练。兼顾生成的韵律和外表的相似,除了面部,考虑到了头部的动作,虑了背景区域的artifact。

南七小僧的学海无涯 3051

浅谈字符串匹配算法—BF算法及KMP算法

字符串匹配,在实际编程中经常遇到。其相应的算法有很多,本文就BF算法和KMP算法,谈一下自己的理解。并结合平时编程,修改了一下,使其更符合我们的使用习惯。(注:标准BF算法和KMP算法,为研究方便,其字符数组[0]存放的都是字符串的长度。本文讲解中,并没有保存字符串长度。后面给出的示例代码中,字符数组中是否保存有字符串长度,都给出了相应的算法代码。) 一、BF算法(Brute Force):

一个程序猿的故事 8285

基于STM32L4XX、HAL库的ICM-42670-P姿态传感器驱动程序设计

sprintf(buffer, "温度: %.1f °C\r\n\r\n", sensor_data.temperature);sprintf(buffer, "陀螺仪: X=%.2f Y=%.2f Z=%.2f rad/s\r\n",sprintf(buffer, "加速度: X=%.2f Y=%.2f Z=%.2f m/s²\r\n",sprintf(buffer, "开始校准IMU,请保持传感器静止...\r\n");sprintf(buffer, "读取传感器数据失败\r\n");

zhusl6688的博客 643

控制算法研发工程师(博士)职位深度解析与面试指南

摘要:广东万和新电气股份有限公司招聘控制算法研发工程师(博士),工作地点佛山顺德。职位要求2026届博士学历,电子信息工程或控制科学与工程专业。主要职责包括:1)燃气热水、热泵等系统的电控软件设计与优化;2)开发PID、模糊控制、ADRC、MPC等智能算法,应用于恒温控制、变频调节等场景。重点考察算法研发能力、系统稳定性优化及嵌入式实现经验。该职位提供三年资深工程师培养计划,需具备扎实的控制理论基础和工程实践能力,能够处理非线性系统、多工况自适应等复杂控制问题。

郑伟强dev的专栏 142

C++ 字符串匹配的BF算法与KMP算法

KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt提出的,因此人们称它为克努特—莫里斯—普拉特操作(简称KMP算法)。KMP算法的核心是利用匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现,函数本身包含了模式串的局部匹配信息。在效率方面KMP算法肯定是优于BF算法的,但是BF算法更加简单直观,容易理解,比较容易实现;KMP 算法的实现相对复杂,需要理解部分匹配表的计算和使用方法。

2302_80101044的博客 1452

【Windows Server 2019】Active Directory Certificate Services 证书颁发机构的安装,配置和管理Ⅰ——AD CS的安装和配置

博文主要介绍了Windows Server 2019的证书颁发机构的安装和配置方法。

VMware, Windows, Linux, Cisco, Container, Kubernetes, Kali 4833

【字符串匹配算法】BF与KMP算法

对BF和KMP进行介绍

caryon的博客 1044

OpenCV开发笔记(〇):使用mingw530_32编译openCV3.4.1源码,搭建Qt5.9.3的openCV开发环境

欢迎技术交流和帮助,提供IT相关服务,索要源码请联系博主QQ: 21497936,若该文为原创文章,未经允许不得转载 原博主博客地址:https://blog.youkuaiyun.com/qq21497936 本文章博客地址:https://blog.youkuaiyun.com/qq21497936/article/details/79641510 目录 OpenCV开发笔记(一):使用mingw530_32编译...

长沙红胖子 Qt・西安|省级科研团队从业背景,深耕双一流体系高精尖技术配套研发|剥离高精尖机理,沉淀高端特种行业领域 Qt 工程化落地经验|博文仅分享通用技术总结,输出公开普适工程思路。 5万+

学Simulink——四开关 Buck‑Boost(FSBB)变换器的无缝模式切换仿真

本文详细介绍了使用Simulink实现四开关Buck-Boost(FSBB)变换器无缝模式切换的仿真方法。FSBB变换器因其输入输出同极性、单电感和双向能量流特性,广泛应用于光伏储能、USB-PD和车载电源等场景。文章重点解决了模式切换中的直通风险和占空比跳变问题,通过统一电压PI控制、Stateflow模式仲裁和200ns死区设计,实现了Buck(26V→24V)、Pass-Through(24V±1V)和Boost(22V)三种工作模式的无缝过渡。仿真结果显示输出电压稳定在12V±0.15V,切换过程无

amy_mhd的博客 68

字符串匹配--BF算法和KMP算法

本章我们一起学习字符串匹配算法–BF算法和KMP算法的实现,希望对大家解决字符串匹配问题有些许帮助!!!🎠🎠🎠。

m0_74288306的博客 1701

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

【字符串匹配算法:BF & KMP】

从BF到KMP

Q1697354625 543

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

字符串匹配 --- BF算法 && KMP算法

对于此时不匹配我们能提取到的一个信息是你其实知道前面六个字符是"ABCDAB",因此我们可以利用这个信息找到最大程度能匹配子串的一部分,此时就是最好的情况这便是KMP算法的核心 --- 利用匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的目的。与BF算法不同的是,当匹配失败时,主串时不回退的,子串回退到相应位置。问题是KMP算法中,当匹配失败时,子串怎么知道该回退到哪个位置?

2301_79448270的博客 1157

字符串匹配—BF算法和KMP算法

BF算法 其思路非常简单 也就是,对这样两个字符串(称短的为模板串,长的为主串): 让主串和模板串的每个字符逐个匹配,如果从这个位置开始匹配不成功,则从主串的下一个字符开始匹配,直到遍历完主串。可以得到这份代码 #include<iostream> #include<stdlib.h> #include<string> using namespace std; int bf(string a, string b) { int la = a.le

m0_60777643的博客 1606

字符串匹配: BF与KMP算法

详细介绍字符串匹配相关的算法, BF是暴力匹配的算法, 而KMP算法中最重要的是要理解next数组原理和作用, 掌握如何求解next数组.

trong_ 的烂笔头 2802
上一篇: 经典十大排序算法的总结与实现
下一篇: STL萃取(Traits)机制
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

code_peak

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值