数据结构（c++) 串的匹配BF->KMP->BM算法

最新推荐文章于 2023-06-05 04:41:53 发布
最新推荐文章于 2023-06-05 04:41:53 发布
阅读量432 收藏 2
点赞数 2
分类专栏： 数据结构 文章标签： c语言 string 模式串匹配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liuqiang1997514/article/details/78370154
版权 
#include<stdio.h> 
#include<stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
#define INFEASIBLE -2

typedef struct 
{
    char *ch;
    int length;
}String;

void String_Assign(String &S,char A[])
{
    int i;
//  if(S.ch)
//      free(S.ch);
    for(i=0;A[i]!='\0';i++);//求字符数组长度
    if(i==0)//字符数组为空
    {
        S.ch=NULL;
        S.length=i;
    }
    else
    {
        S.ch=(char *)malloc(i*sizeof(char));//申请空间并判断是否为空
        if(!S.ch)
            exit(OVERFLOW);
        S.length=i;
        for(i=0;i<S.length;i++)//逐一复制字符
            S.ch[i]=A[i];
    }
}//字符串赋值

void String_Init(String &S)
{
    char A[255];
//  printf("请输入字符串:\n");
    gets(A);//输入字符数组
    String_Assign(S,A);//给字符串赋值
}//输入赋值

int String_Length(String S)
{
    return S.length;
}//返回字符串长度

void String_Show(String S)
{
    int i;
    for(i=0;i<S.length;i++)//逐个输出字符
        printf("%c",S.ch[i]);
    printf("\n");
}//出处字符串
/*
int String_Compare(String A,String B)
{
    int i;
    for(i=0;i<A.length&&i<B.length;i++)
        if(A.ch[i]!=B.ch[i])//两个对应位置字符不相同时
            break;
    return A.ch[i]-B.ch[i];//返回两者差值
}//字符串比较

void String_Clear(String &S) 
{
    if(S.ch)
    {
        free(S.ch);//释放空间
        S.ch=NULL;
    }
    S.length=0;
}//清空字符串
 */
void String_Contact(String &M,String S1,String S2)
{
    int i,j;
//  if(M.ch)
//      free(M.ch);
    M.ch=(char *)malloc((S1.length+S2.length)*sizeof(char));//申请新空间并判断是否成功
    if(!M.ch)
        exit(OVERFLOW);
    M.length=S1.length+S2.length;//初始化长度
    for(i=0;i<S1.length;i++)
        M.ch[i]=S1.ch[i];//把第一个字符串逐个复制
    for(j=0;j<S2.length;i++,j++)
        M.ch[i]=S2.ch[j];//逐个复制第二个字符串
}//字符串链接
/*
int String_Sub(String S,String &Sub,int Pos,int len)
{
    int i;
    if(Pos<0||Pos>S.length||len<0||Pos+len-1>S.length)//截取位置与长度是否合法
        return ERROR;
//  if(Sub.ch)
//      free(Sub.ch);
    if(len==0)//截取长度为0的情况
    {
        Sub.ch=NULL;
        Sub.length=0;
    }
    else
    {
        Sub.ch=(char *)malloc(len*sizeof(char));//申请空间并判断是否成功
        if(!Sub.ch)
            exit(OVERFLOW);
        Sub.length=len;//初始化长度
        for(i=0;i<Sub.length;i++,Pos++)//组个取值复制字符
            Sub.ch[i]=S.ch[Pos];
    }
    return OK;
}//截取子串

int String_Replace(String &S,String T,String V)
{
    int i,State;
    String Sub,Temp;
    for(i=0;i<S.length;i++)
    {
        State=String_Sub(S,Sub,i,T.length);//取相同长度子串
        if(State==ERROR)
            return ERROR;
        if(String_Compare(Sub,T)==0)//判断两者是否相等
            break;  
    }
    State=String_Sub(S,Temp,0,i);//将替换子串前的子串取出
    State=String_Sub(S,T,i+T.length,S.length-i-T.length);//将替换子串后的子串取出 
    String_Contact(Sub,Temp,V);//链接第一个子串和第二个子串
    String_Contact(S,Sub,T);//将前两个子串和最后一个子串链接
    return OK;
}//替换子串

int String_Delete(String &S,String T)
{
    int i,State,flag;
    String Sub,Temp;
    if(T.length==0)
        return ERROR;
    for(i=S.length-T.length;i>=0;i--)
    {
        State=String_Sub(S,Sub,i,T.length);//逐个取子串
        if(String_Compare(Sub,T)==0)//比较子串与目标串是否相等
        {
            flag=1;
            State=String_Sub(S,Sub,0,i);//取子串前一个子串
            State=String_Sub(S,Temp,i+T.length,S.length-i-T.length);//取子串后一个子串
            String_Contact(S,Sub,Temp);//链接两个子串
        }
    }
    if(flag==0)
        return ERROR;
    else
        return OK;      
}//删除子串

int String_BFmatch(String S,String T,int Pos[],int &N)
{
    int i,State;
    String Sub;
    N=0;
    Pos[0]=-1;
    for(i=0;i<=S.length-T.length;i++)
    {
        State=String_Sub(S,Sub,i,T.length);//逐个取子串
        if(State==ERROR)
            return ERROR;
        if(String_Compare(Sub,T)==0)//比较子串与目标串是否相等
            Pos[N++]=i;//存储位置
    }
    if(Pos[0]==-1)
        return ERROR;
    else
        return OK;
}//BF匹配算法
*/
void KMP_Next(String p,int next[])
{
    int j,k;
    next[0]=0;
    for(k=0,j=1;j<p.length;j++)
    {
        while(k>0&&p.ch[k]!=p.ch[j])
            k=next[k];//不等时递推寻找最长前缀
        if(p.ch[k]==p.ch[j])
            k++;//相等时，前缀直接加1
        next[j]=k;
    }
}//KMP算法跳转数组

int String_KMPmatch(String S,String T,int Pos[],int &N)
{
    int *next,i,j=0;
    next=(int *)malloc(T.length*sizeof(int));//申请空间构建next数组
    KMP_Next(T,next);
    N=0;
    Pos[0]=-1;
    for (i=0;i<S.length;i++) 
    {
        while (j>0&&S.ch[i]!=T.ch[j])//逐个比较模式串与主串
            j=next[j];//不匹配就跳转
        if(S.ch[i]==T.ch[j])
            j++;//匹配则移位
        if (j==T.length) 
        {
            Pos[N++]=i-j+1;//存储位置
            j=0;
        }
    }
    if(Pos[0]==-1)
        return ERROR;
    else
        return OK;
}//KMP算法
/*
void BM_Badc(String S,int BC[])
{
    int i;
    for(i=0;i<256;i++)//将所有字符都赋值为最大距离
        BC[i]=S.length;
    for(i=0;i<S.length;i++)//将模式串中的字符从新覆盖赋值为到串尾的距离
        BC[S.ch[i]]=S.length-i-1;
}//BM算法坏字符数组

void GoodS_Suffix(String S,int Suffix[])
{
    int i,j;
    Suffix[S.length-1]=S.length;
    for(i=S.length-2;i>=0;i--)
    {
        j=i;
        while(j>0&&S.ch[j]==S.ch[S.length-i-1+j])//求好后缀的长度
            j--;
        Suffix[i]=i-j;
    }
}//BM算法好后缀长度数组

void BM_Goods(String S,int GS[])
{
    int i,j,*Suffix;
    Suffix=(int *)malloc(S.length*sizeof(int));//申请好后缀长度数组
    if(!Suffix)
        exit(INFEASIBLE);
    GoodS_Suffix(S,Suffix);
    for(i=0;i<S.length;i++)//不存在匹配前缀则直接跳转模式串长度
        GS[i]=S.length;
    j=0;
    for(i=S.length-1;i>=0;i--)
        if(Suffix[i]==i+1)
            for (;j<S.length-1-i;j++)
                if (GS[j]==S.length)
                    GS[j]=S.length-1-i;//存在子串
    for (i=0;i<=S.length-2;i++)
            GS[S.length-1-Suffix[i]]=S.length-1-i;//存在相同的串
}//BM算法好后缀数组

int String_BMmatch(String S,String T,int Pos[],int &N)
{
    int i, j,*GS,*BC;
    BC=(int *)malloc(256*sizeof(int));
    if(!BC)
        exit(INFEASIBLE);
    GS=(int *)malloc(T.length*sizeof(int));
    if(!GS)
        exit(INFEASIBLE);
    BM_Badc(T,BC);
    BM_Goods(T,GS);//申请好后缀与坏字符空间
    j=0;
    N=0;
    Pos[0]=-1;
    while (j<=S.length-T.length) 
    {
        for (i=T.length-1;i>=0&&T.ch[i]==S.ch[i+j];i--);//从模式串尾部开始比较
        if (i<0) 
        {
            Pos[N++]=j;//存储位置
            j+=GS[0];//寻找下一个目标串
        }
        else
            j+=GS[i]>(BC[S.ch[i+j]]-T.length+1+i)?GS[i]:(BC[S.ch[i+j]]-T.length+1+i);//匹配失败时跳转最大长度
    }
    if(Pos[0]==-1)
        return ERROR;
    return OK;
}//BM算法
*/
void String_Read(String &S)
{
    FILE *fp;
    char str[1000];
    String Temp;
    fp=fopen("test.txt","r");//打开文件
    if(!fp)
        exit(INFEASIBLE);
    fgets(str,100,fp);
    String_Assign(S,str);//读取文件第一行并存储
    S.length--;//删除尾部换行符
    while(fgets(str,100,fp))
    {
        String_Assign(Temp,str);//逐个读取文件每行的字符串
        Temp.length--;//删除尾部换行符
        String_Contact(S,S,Temp);//链接
    }
    fclose(fp);
}//读取文件

int main()
{
    String S,T;
    int Pos[100],N,State,i;
    String_Read(S);
    String_Show(S);
    printf("\n请输入查找字符串:");
    String_Init(T);
/*  printf("----------B F算法----------\n");
    State=String_BFmatch(S,T,Pos,N);
    if(State==ERROR)
        printf("查找不到!\n\n");
    else
    {
        for(i=0;i<N;i++)
            printf("在位置%03d处发现目标字符串!\n",Pos[i]);
        printf("\n");
    }*/
    printf("----------KMP算法----------\n");
    State=String_KMPmatch(S,T,Pos,N);
    if(State==ERROR)
        printf("查找不到!\n\n");
    else
    {
        for(i=0;i<N;i++)
            printf("在位置%03d处发现目标字符串!\n",Pos[i]);
        printf("\n");
    }
/*  printf("----------B M算法----------\n");
    State=String_BMmatch(S,T,Pos,N);
    if(State==ERROR)
        printf("查找不到!\n\n");
    else
    {
        for(i=0;i<N;i++)
            printf("在位置%03d处发现目标字符串!\n",Pos[i]);
        printf("\n");
    }*/
    return 0;
}
纳兰容若-当时只道是寻常
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BM算法的c语言实现
10-11
基础算法BM算法 密码学非常重要的算法！包括整个工程
BM模式匹配算法-实现（C语言）
ouyangjia7的专栏
03-22 769
    也许大家都看过了我的另一篇帖子——BM模式匹配算法-原理（图解） ，如果想仔细弄懂这个算法的朋友，请先看完方才我提到的那篇帖子，不然这篇帖子的代码你也很难看懂。     BM算法的实现很复杂，但是高手程序员就是能写出令人敬佩的代码。     当然，高手程序员不是指我自己，是SNORT2.7.0的设计者/实现者之一。       下面是SNORT2.7.0中提取出的代码。   ...
数据结构 BM算法
aotangai1607的博客
10-26 856
　　BM算法是比KMP算法更快的字符串模式匹配算法。BM算法最好情况下的时间复杂度是O(n)，KMP算法最好情况下的时间复杂度是O(n+m)，两者最坏情况下的时间复杂度均是O(m*n)。其中，n指目标串长度，m指模式串长度。 　　KMP算法从左向右比较，通过失配时已匹配的字符信息来确定下一次匹配时模式串的起始位置。BM算法从右向左比较，运用了两种启发式规则：坏字符规则和好后缀规则，取这...
C++ BF模式串匹配算法！
Menlody的博客
03-17 772
#include using namespace std; int BF(char S[], char T[]){ int index = 0; int i = 0; int j = 0; while((S[i] !='\0') && (T[j] != '\0') && (strlen(S)-i+1>=strlen(T)-j+1)){ if (S[i]==T[j]) {i++
BM算法C语言实现
jiwangkailai02的专栏
05-03 6318
前些日子分析了一下BM算法，时间上断断续续的，效率很低，今天上午才算最后完工，关于BM算法我主要参考了以下内容： 1.http://ouyangjia7.iteye.com/blog/353137 2.http://blog.csdn.net/chong232/archive/2010/08/12/5806968.aspx 这两篇文章都写得很好，给我有很多帮助，但是看上面的源代码有一些地方我
字符串的模式匹配详解--BF算法与KMP算法
09-04
记录一下串里面的模式匹配，模式匹配，顾名思义就是给定一个被匹配的字符串，然后用一个字符串模式（模型）去匹配上面说的字符串，看后者是否在前者里面出现。常用的有2种算法可以实现，下面我们来具体探讨下
DS串应用--KMP算法
10-25
DS串应用--KMP算法DS串应用--KMP算法DS串应用--KMP算法DS串应用--KMP算法
数据结构（C语言）--模式匹配--KMP算法
10-18
《数据结构》用C语言实现的模式匹配KMP算法，可用于求出子串在主串中的位置。
数据结构-KMP算法原理
最新发布
04-10
对KMP算法进行具体的分析，生动图解，保证能够一看就懂
java 中模式匹配算法-KMP算法实例详解
08-30
主要介绍了java 中模式匹配算法-KMP算法实例详解的相关资料,需要的朋友可以参考下
BM算法完整实现C代码
12-24
大字符串查找时,效率会比线性查找好些; zip 解压后, 添加至console工程即可
BM模式串匹配C语言实现
06-22
GCC编译可用，该程序支持a-z的字符串（注意空格也不在内），如果查找字段需要扩大，可以修改代码增加范围
字符串匹配BM
06-12
Boyer-Moore字符串搜索算法是一种非常高效的字符串搜索算法。它由Bob Boyer和J Strother Moore设计于1977年。此算法仅对搜索目标字符串（关键字）进行预处理，而非被搜索的字符串。虽然Boyer-Moore算法的执行时间同样线性依赖于被搜索字符串的大小，但是通常仅为其它算法的一小部分：它不需要对被搜索的字符串中的字符进行逐一比较，而会跳过其中某些部分。通常搜索关键字越长，算法速度越快。它的效率来自于这样的事实：对于每一次失败的匹配尝试，算法都能够使用这些信息来排除尽可能多的无法匹配的位置。
[C/算法]字符串匹配(BF算法的改进算法:KMP算法和BM算法)
08-27
实现BF算法的改进算法:KMP算法和BM算法； 对上述3个算法进行时间复杂性分析，并设计实验程序验证分析结果。 附件中 3.3.h BF算法代码 3.5.h KMP算法代码 3.12.h BM算法代码
c++ kmp算法字符匹配_字符串匹配算法总结——BF、KMP、BM
weixin_39779739的博客
11-26 169
说明以下算法介绍中，被匹配字符串称为主串，匹配模式字符串称为匹配串，索引从0开始。前缀数组：字符串S = AB（B !== ⏀，即B为任一非空字符串) ，S的前缀指A。前缀数组指所有包含第一个字符但不包含最后一个字符的子串集合。后缀数组：字符串S = AB（A !== ⏀，即A为任一非空字符串) ，S的后缀指B。后缀数组指所有包含最后一个字符但不包含第一个字符的子串集合。一、BFBrute For...
字符串匹配(BF,KMP,BM)
CSDN
12-30 3699
一.暴力匹配法        最原始,最直观的办法,就是蛮力搜索法,思路是这样子的,需要在str1中寻找str2,那么可以先在str1中查找str2[0],如果找到,则比较往后的字符, 如果全匹配,则返回一开始的符号,如果不匹配,继续在str1中找str2[0],一直重复以上步骤,直至找到为止.分析这种办法的时间复杂度.在最差的情 况下,例如长度为m的字符串0000000000,和长度为n的...
算法数据结构——字符串搜索算法BM（Boyer Moore）精讲及python实现
白话机器学习
06-05 1161
Boyer Moore 算法：简称为 BM 算法，是由它的两位发明者 Robert S. Boyer 和 J Strother Moore 的名字来命名的。BM 算法是他们在 1977 年提出的高效字符串搜索算法。在实际应用中，比 KMP 算法要快 3~5 倍。BM 算法思想：对于给定文本串T与模式串p，先对模式串p进行预处理。然后在匹配的过程中，当发现文本串T的某个字符与模式串p不匹配的时候，根据启发策略，能够直接尽可能地跳过一些无法匹配的情况，将模式串多向后滑动几位。
串匹配——bf、kmp、bm算法
yisandezhuiqiu的博客
11-22 2033
问题描述：给定一个文本，在该文本中查找并定位任意给定字符串：给定两个串和，在主串S中查找子串T的过程，T为模式。 1、bf算法 蛮力法 对主串与模式串一个一个进行比较，若不匹配，则模式串从第一个字符开始，主串往后一个字符，再进行下一趟比较；若匹配，则模式串与主串字符往后进行比较。 直到主串s所剩字符长度小于模式串t长度或模式串所有字符比较完毕。 #include<stdio.h&...
BM算法
lmhine的专栏
07-19 3158
由于毕业设计（入侵检测）的需要，这两天仔细研究了BM模式匹配算法，稍有心得，特此记下。   首先，先简单说明一下有关BM算法的一些基本概念。   BM算法是一种精确字符串匹配算法（区别于模糊匹配）。   BM算法采用从右向左比较 的方法，同时应用到了两种启发式规则，即坏字符规则
串的模式匹配算法--BF算法/KMP算法
11-23
BF算法和KMP算法都是串的模式匹配算法，但是它们的时间复杂度不同。BF算法的时间复杂度为O(m*n)，其中m和n分别为主串和模式串的长度。而KMP算法的时间复杂度为O(m+n)。因此，当模式串较长时，KMP算法的效率更高。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值