精华内容
下载资源
问答
  • 一.BF算法  BF算法是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串P的第一个字符进行匹配,若相等,则继续比较S的第二个字符和P的第二个字符;若不相等,则比较S的第二个字符和P的第一个字符...
  • 记录一下串里面的模式匹配,模式匹配,顾名思义就是给定一个被匹配的字符串,然后用一个字符串模式(模型)去匹配上面说的字符串,看后者是否在前者里面出现。常用的有2种算法可以实现,下面我们来具体探讨下
  • 主要介绍了python通过BF算法实现关键词匹配的方法,实例分析了BF算法的原理与Python实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 给定一个子串,要求找出某个字符串中该子串的第一次出现的位置,即实现各种模式匹配。本资源中含有bf算法,和kmp算法,以及改进后的kmp算法
  • 课程的随堂作业,C语言的,用dev就能运行,萌新代码,勿喷,仅仅帮助不想写作业的朋友方便一下,反正老师也不会仔细检查的
  • BF算法

    2021-06-20 01:12:33
    BF算法,即暴力(Brute Force)算法,是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配,若相等,则继续比较S的第二个字符和 T的第二个字符;若不相等,则比较S的第二个...

    BF算法,即暴力(Brute Force)算法,是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配,若相等,则继续比较S的第二个字符和 T的第二个字符;若不相等,则比较S的第二个字符和T的第一个字符,依次比较下去,直到得出最后的匹配结果。BF算法是一种蛮力算法。

    中文名

    BF算法

    B    F

    Brute Force属    于

    普通的模式匹配算法

    最坏情况

    要进行M*(N-M+1)次比较

    BF算法算法思想

    编辑

    语音

    首先S[1]和T[1]比较,若相等,则再比较S[2]和T[2],一直到T[M]为止;若S[1]和T[1]不等,则S向右移动一个字符的位置,再依次进行比较。如果存在k,1≤k≤N,且S[k+1…k+M]=T[1…M],则匹配成功;否则失败。

    该算法最坏情况下要进行M*(N-M+1)次比较,时间复杂度为O(M*N)。

    举例说明:

    S: ababcababa

    T: ababa

    BF算法匹配的步骤如下:i=0, j=0i=1, j=1i=2,j=2i=3, j=3i=4, j=4(失败)

    ababcababaababcababaababcababaababcababaababcababa

    ababaababaababaababaababai=1,j=0(失败)

    ababcababa

    ababai=2,j=0i=3,j=1i=4,j=2(失败)

    ababcababaababcababaababcababa

    ababaababaababai=3,j=0(失败)

    ababcababa

    ababai=4,j=0(失败)

    ababcababa

    ababai=5,j=0i=6,j=1i=7,j=2i=8,j=3i=9,j=4(成功)

    ababcababaababcababaababcababaababcababaababcababa

    ababaababaababaababaababa

    BF算法C语言实现:

    编辑

    语音

    int Index(SString S,SString T,int pos)

    { /* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数值为0。 */

    /* 其中,T非空,1≤pos≤StrLength(S)。算法4.5 */

    int i,j;

    if(1<=pos&&pos<=S[0])

    {

    i=pos;

    j=1;

    while(i<=S[0]&&j<=T[0])/*S[0],T[0]中存放的为串长*/

    if(S[i]==T[j]) /* 继续比较后继字符 */

    {

    ++i;

    ++j;

    }

    else /* 指针后退重新开始匹配 */

    {

    i=i-j+2;

    j=1;

    }

    if(j>T[0])

    return i-T[0];

    else

    return 0;

    }

    else

    return 0;

    }

    BF算法C#语言实现:

    编辑

    语音

    static int BPTest(string haystack, string needle)

    {

    int needleLen = needle.Length;

    for (int i = 0; i <= haystack.Length - needleLen; i++)

    {

    for (int j = 0; j < needleLen; j++)

    {

    if (haystack[j + i] != needle[j])

    {

    break;

    }

    if (j == needleLen - 1)

    {

    return i;

    }

    }

    }

    return -1;

    }

    词条图册

    更多图册

    展开全文
  • 模式匹配—从BF算法优化到KMP算法,含有详细注释,对应的讲述该算法的博文地址:http://blog.csdn.net/ns_code/article/details/19286279
  • 装箱问题是NP问题。该文对装箱问题的BF算法进行了分析,用Visual C++实现该算法。
  • BF算法和KMP算法

    2012-10-17 21:30:51
    个人对BF和KMP算法的简单理解,部分做了相对完善,希望对你有帮助,
  • C语言实现BF算法

    2021-05-20 09:41:04
    //头文件#include //字符串头文件int BF(char s[],char t[],int pos){ //BF算法 s是原字符串,t是匹配字符串intm,n;inti=pos,j=0; //从0位置开始匹配m=strlen(s);n=strlen(t); //用m,n表示s,t长度while (i<=m&...

    //头文件

    #include //字符串头文件

    int BF(char s[],char t[],int pos){     //BF算法 s是原字符串,t是匹配字符串

    intm,n;

    inti=pos,j=0;          //从0位置开始匹配

    m=strlen(s);

    n=strlen(t);             //用m,n表示s,t长度

    while (i<=m&&j<=n){               //m,n是串长

    if (s[i]==t[j])

    {

    i++;

    j++;        //逐个匹配,成功s++   t++

    }

    else

    {

    i=i-j+1;       //不成功,s返回到此次循环匹配的初始位置

    j=0;           //不成功,t返回到0位置

    }

    }

    if(j>n)

    return (i-n);          //返回匹配成功的原串中第一个字符的位置

    else

    return 0;

    }

    int main(){

    char s[]="abcdkeabcfgabcde";      //初始定义s串

    int pos;

    pos=BF(s,"abcd",0);        //从0位置匹配abcd

    printf("pos=%d\n",pos);

    pos=BF(s,"abcde",pos);    //从上次匹配成功的位置匹配abcde

    printf("pos=%d\n",pos);

    return0;

    }

    展开全文
  • BF算法与KMP算法

    2020-07-21 16:20:06
    BF算法与KMP算法都是用来查找主串中子串的位置,也就是模式匹配。 BF算法的简单粗暴,缺点是每趟匹配不成功时,存在大量回溯,导致程序效率低下,而KMP算法充分利用了成功匹配部分的结果,保证了主串游标不回溯,...

    BF算法与KMP算法都是用来查找主串中子串的位置,也就是模式匹配。
    BF算法的简单粗暴,缺点是每趟匹配不成功时,存在大量回溯,导致程序效率低下,而KMP算法充分利用了成功匹配部分的结果,保证了主串游标不回溯,通过模式串向右滑动代替模式串游标回溯,大大提高了程序运行效率。
    简单的了解了一下BF和KMP算法的作用和优缺点后,我们先来看一下具体的代码和细节

    先看BF算法(这个算法比较简单,就不多说了直接上代码)

    #include<iostream>
    #include<string.h>
    using namespace std;
    int BF(char S[],char T[])
    {
        int i=0, j=0,len1=strlen(S),len2=strlen(T);
       for(i;i<len1;i++)
       {
           if(S[i]==T[j])
            j++;
           else
           {
               i=i-j+1;
               j=0;
           }
           if(j==len2)return i-j+1;
       }
       return -1;
    }
    int main()
    {
        char a[20],b[5];
        cin>>a>>b;
        cout<<BF(a,b);
    }
    

    关于KMP算法,主要的难点在于next数组的计算
    在这之前,我们已经知道了主串指针i可以不回溯,模式串向右滑动到新的比较起点k,并且k仅与模式串T有关,
    那么如何由当前部分匹配结果确定模式向右滑动的新比较起点k?
    模式应该向右滑动多远才是效率最高的?

    解决了这两个问题,next的计算也就简单了
    这样,我们通过T[0]-T[K-1]=T[J-K]~T[J-1]可以确定每次匹配失败时应该回溯的位置k,而滑动多远才是效率最高的问题取k中最大值即可
    接下来是具体的代码

    #include<string>
    #include<iostream>
    using namespace std;
    void Getnext(string t, int next[])
    {
    	int j = 0, k = -1;
    	next[0] = -1;
    	while (j < t.length() )
    	{
    		if (k == -1 || t[j] == t[k])
    		{
    			j++; k++;
    			next[j] = k;
    		}
    		else k = next[k];
    	}
    }
    int KMP(string p, string t)
    {
    	int i = 0, j = 0;
    	int* next = new int[t.length()];
    	Getnext(t, next);
    	for (int i = 0; i < t.length(); i++)
    		cout << next[i] << " ";
    	cout << endl;
    	while (i < p.length() && j < t.length())
    	{
    		if (p[i] != t[j])
    		{
    			j = next[j];//匹配失败,模式串向右滑动至next[j](也就是之前说的k)
    		}
    		if (p[i] == t[j] || j == -1)
    		{
    			j++; i++;
    		}
    	}
    	if (j >= t.length())return i - t.length();
    	else return -1;
    }
    int main()
    {
    	string p = "DABCDDACBAEDABCFDABCDABD";
    	string t = "DABCDABD";
    	cout << " ";
    	for (int i = 0; i < t.length(); i++)
    		cout << t[i] << " ";
    	cout << endl;
    	cout<<KMP(p, t);
    }
    
    
    展开全文
  • BF算法 KMP算法

    BF算法


    BF(Brute Force)算法,即暴力算法,是普通的串的模式匹配算法,BF算法是一种蛮力算法

    BF算法的思想就是将目标串S(主串)的第一个字符与模式串T(子串)的第一个字符进行匹配,若相等,则继续比较S的第二个字符和 T的第二个字符;若不相等,则比较S的第二个字符和T的第一个字符,依次比较下去,直到得出最后的匹配结果

    BF算法效率并不高,因为每次没找到,主串都要回退到上一次开始的下一个位置

    BF算法时间复杂度O(m*n) 空间复杂度O(1)

    BF算法图解如下:
    在这里插入图片描述

    C代码如下:

    //返回 子串T 在 主串S 中第pos个字符之后的位置
    //时间复杂度:O(m*n) 空间复杂度:O(1)
    
    int BF(const char* S, const char *T,int pos)  //S主串,T子串
    {
    	if (S == NULL || T == NULL || pos < 0 || pos >= strlen(S))
    	{
    		return -1;
    	}
    
    	int i = pos;
    	int j = 0;
    	int len1 = strlen(S);//主串长度
    	int len2 = strlen(T);//子串长度
    
    	while(i<len1&&j<len2)
    	{
    		if (S[i] == T[j])
    		{
    			i++;
    			j++;
    		}
    		else
    		{
    			/*回退到本次开始的下一个位置(i-j+1),j回退到0*/
    			i = i - j + 1;
    			j = 0;
    		}
    	}
    
    	if (j >= len2)  //子串走完即为查找成功
    		return i - j ;
    	else  
    		return -1;
    }
    

    BF算法的效率不高,时间复杂度O(m*n),每次匹配失败主串游标 i 都要回退到本次开始的下一个位置,子串游标 j 要回退到0。而KMP算法改进了i,j的回退,避免了不必要的回溯,提高了效率,时间复杂度降到了O(m+n)

    KMP算法


    KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt提出的,取他们姓首字母,即为KMP算法。KMP算法的核心是利用匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的目的

    KMP算法时间复杂度O(m+n) 空间复杂度O(n)

    在BF算法中,每次失配,主串游标 i 都要回退到 i-j+1,子串游标 j 要回退到0

    但是其实在出现失配时,可以让 i 不回退,j 回退到该退的位置即可,如下图BF算法示意图中,第一次失配后,i 回溯到 i-j+1,j 回溯到0,但是我们可以发现之后的比较中,i 又回到了之前的位置,j 位置改变了而已(下图红框)

    在这里插入图片描述
    KMP算法就是在出现失配时,让主串游标 i 不回退,利用之前失败的信息,让子串游标 j 退回到合适的位置

    所以关键就是求出失配后子串游标 j 应该回溯的位置,我们用一个next数组来存储子串每个位置对应的 j 应该回溯的位置

    把上面BF算法代码直接拷贝过来,修改 i,j 的回退即可完成KMP算法的大框架

    int KMP(const char* S, const char *T,int pos)  //S主串,T子串
    {
    	if (S == NULL || T == NULL || pos < 0 || pos >= strlen(S))
    	{
    		return -1;
    	}
    
    	int i = pos;
    	int j = 0;
    	int len1 = strlen(S);//主串长度
    	int len2 = strlen(T);//子串长度
    
    	while(i<len1&&j<len2)
    	{
    		if (S[i] == T[j])
    		{
    			i++;
    			j++;
    		}
    		else//修改i,j的回退
    		{
    			//i不回退
    			//j要退到k
    		}
    	}
    
    	if (j >= len2)  //子串走完即为查找成功
    		return i - j ;
    	else  
    		return -1;
    }
    

    接下来的任务就是要把 j 回退的位置 k 给求出来,即求出next数组


    求next数组

    预备知识:字符串的前缀、后缀

    前缀:首字符开始的子串
    真前缀:首字符开始的子串,但不包含原串本身
    后缀:以尾字符结尾的子串
    真后缀:以尾字符结尾的子串,但不包含原串本身
    例:ababc
    前缀:a、ab、aba、abab、ababc
    真前缀:a、ab、aba、abab
    后缀:c、bc、abc、babc、ababc
    真后缀:c、bc、abc、babc

    如下例中
    在这里插入图片描述
    在 i 是4,j 是4时发生失配,但是我们发现失配前的S串真后缀与T串真前缀出现相等相等的部分就不用比较了,因此直接从相等的后面开始继续比较就好(如下图),即j回溯到相等串的后面,即j下标变为相等串的长度,所以关键就是求每次失配这个相等串的长度 k

    又因为第一次比较中,失配前的四个字符S串与T串都是一一对应相等的,因此S串的真后缀也是T串的真后缀,因此k就是T串失配前的串的真前缀与真后缀相等时的长度值
    在这里插入图片描述
    因而求k值的方法就是:在子串失配前找到相等的真前缀与真后缀,其长度就是k或者可以这样描述:

    在子串失配前找到最长两个相等的真子串,这两个真子串满足如下特点:
    1.一个串以首字符开头
    2.另一个串以失配前的最后一个字符作为结尾
    k就是该真子串的长度

    上例T串每个字符对应的k值如下:
    规定:next[0]=-1,next[0]=0

    模式串T串ababc
    next-10012

    注意:还有一种常用的next数组表示,next[0]放的是0,next[1]是1,后续每一个k值都比上表里的大1,但是算法思路都是一样的,二者皆可,为便于编码,这里采用next[0] = -1这种方法

    手动已经可以求出next数组的值了,接下来就是用程序具体求出next数组:

    1. 对于任意串都可以确定其next[0] = -1,next[1] = 0;
    2. 设next[j] = k,即下标 j 之前的串的真前缀与真后缀相等的长度为k,即P0…Pk-1 == Pj-k…Pj-1,求next[j+1]
    3. 情况一:若Pk == Pj,则P0…Pk-1Pk = Pj-k…Pj-1Pj,即j+1对应的真前缀与真后缀相等时的值是k+1,即next[j+1] = k+1
    4. 情况二:若Pk != Pj,如下图,把P0…Pk放到Pk…Pj下面来看,则又要用到之前的思想,主串游标j不动,子串游标k往回退到合适位置,而子串游标k回退的位置在之前已经求出来了,是next[k],所以k回退到next[k],即k=next[k],之后Pk再与Pj比较,如此往复直到Pk==Pj或k回溯到-1,k回溯到-1说明没有相等的真前缀与真后缀,那么next[j+1]赋值为0即可,或者next[j+1]=k+1,这也是next数组的第一个k值放-1的好处
      在这里插入图片描述
    5. next数组的C代码:
    static void GetNext(const char* T,int * next)  //根据子串T获取它的next数组(用来存放所有的k值)
    {
    	int lenT = strlen(T);
    	if(lenT == 1)   {	next[0] = -1; return;	}
    	next[0] = -1;
    	next[1] = 0;
    	int j = 1;
    	int k = 0;
    
    	while (j + 1 < lenT)
    	{
    		if (k == -1 || T[k] == T[j])//Pk==Pj,k为-1就没必要回退了
    		{
    			/*
    			next[j + 1] = k + 1;
    			j++;
    			k++;
    			*/
    			next[++j] = ++k;
    		}
    		else//Pk != Pj
    		{
    			k = next[k];//主串游标j不动,子串游标k往回退
    		}
    	}
    }
    

    至此,next数组已经求出,即主串游标不动、子串游标j回退的位置已经求出,最后把j = next[j]放入失配条件下,KMP算法就完成了,KMP算法全部的C代码如下:

    static void GetNext(const char* T, int * next);  //声明获取next数组的函数
    
    int KMP(const char* S, const char *T, int pos)  //S主串,T子串
    {
    	if (S == NULL || T == NULL || pos < 0 || pos >= strlen(S))
    	{
    		return -1;
    	}
    
    	int i = pos;
    	int j = 0;
    	int len1 = strlen(S);//主串长度
    	int len2 = strlen(T);//子串长度
    
    
    	int *next = (int *)malloc(len2 * sizeof(int));
    	GetNext(T, next);//求next数组
    
    	while (i < len1&&j < len2)
    	{
    		if (j==-1 || S[i] == T[j])
    		{
    			i++;
    			j++;
    		}
    		else
    		{
    			//i不回退
    			j = next[j];//j回退到k
    		}
    	}
    	free(next);
    	if (j >= len2)  //子串走完即为查找成功
    		return i - j;
    	else
    		return -1;
    }
    static void GetNext(const char* T, int * next)  //根据子串T获取它的next数组(用来存放所有的k值)
    {
    	int lenT = strlen(T);
    	if(lenT == 1)   {	next[0] = -1; return;	}
    	next[0] = -1;
    	next[1] = 0;
    	int j = 1;
    	int k = 0;
    
    	while (j + 1 < lenT)
    	{
    		if (k == -1 || T[k] == T[j])//Pk==Pj,k为-1就没必要回退了
    		{
    			/*
    			next[j + 1] = k + 1;
    			j++;
    			k++;
    			*/
    			next[++j] = ++k;
    		}
    		else//Pk != Pj
    		{
    			k = next[k];//主串游标j不动,子串游标k往回退
    		}
    	}
    }
    
    展开全文
  • C++实现BF算法和KMP算法

    千次阅读 多人点赞 2020-04-14 18:25:17
    给定两个字符串S和T,在主串S中查找子串T的过程称为串匹配(string matching,也称模式匹配),T称为模式。这里将介绍处理串匹配问题的两种算法,BF算法和KMP算法。
  • 数据结构:BF算法

    2021-05-20 09:41:16
    贴上源代码:#includeusing ...int BF(char S[],char T[]){int i,j;i = j = 0;while(S[i]!='\0'&&T[j]!='\0'){if(S[i]==T[i]){i++;j++;}else{j = 0;i = i-j+1;}}if(T[j]=='\0')return i -j+1;elseretur...
  • KMP算法一直让我们又爱又恨,...因为暴力匹配算法(BF算法)是学习KMP的前提, 因此,我们通过讲解BF算法,来引入KMP算法。 串的模式匹配的概念: 顾名思义,模式串B在文本串(主串)A中的查找过程,我们称为模式匹配。
  • BF算法和KMP算法详解

    千次阅读 2020-02-07 00:01:09
    BF算法(穷举法) <2>KMP算法 BF算法 算法的思路 具体过程 子串位置的计算 代码实现 时间复杂度 KMP算法 求解next的方法 求next[j+1] 使用next数组来实现过程 代码实现 next 数组的优化 代码...
  • BF算法详解

    千次阅读 多人点赞 2019-02-15 11:30:16
    BF算法 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; BF(Brute Force)算法也就是传说中的“笨办法”,是一个暴力/蛮力算法。设串S和P的长度分别为m,n,则它在最坏情况下的时间复杂度...
  • 串的模式匹配算法(KMP算法,BF算法+算法详解+实现代码) 子串的定位操作是找子串在主串中从第pos个字符后首次出现的位置,又被称为串的模式匹配 一、BF模式匹配算法 BF算法思想:Brute-Force算法又称蛮力匹配算法...
  • 浅谈BF算法的C++实现

    2021-11-10 18:07:49
    BF算法使用面向结构的思想即可。 算法函数 int BF(char s[],char t[]){ int start=0; //start记录开始比较的位置,从主串头开始 int i=0,j=0; //i,j分别为主串、子串循环变量 while((s[i]!='\0'
  • 【数据结构与算法】BF算法(详解)

    万次阅读 多人点赞 2019-04-18 12:00:10
    目录(一)BF算法(二)演示(三)时间复杂度(四)代码实现 我的KMP算法 点我 (一)BF算法 也就是串的模式匹配算法,在主串中查找与模式T(副串)相匹配的子串,如果匹配成功,找到该子串在主串出现的第一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,081
精华内容 20,432
关键字:

bf算法

友情链接: opc3.00.108-20191220.zip