精华内容
下载资源
问答
  • 实验二 串模式匹配算法(串实验) 实现功能:朴素的模式匹配算法(BF算法)、KMP改进算法(Next[ ])、KMP改进算法(NextVal[ ])。 主控菜单: 1.输入主串、子串和匹配起始位置 2.朴素的模式匹配算法 3.KMP改进算法...
  • 《数据结构(C语言版 第2版)》严蔚敏 实验四 基于字符串模式匹配算法的病毒感染检测问题,含实验报告
  • C/C++实现匹配算法,包括源代码和实验报告。实现了的创建,查看,修改,朴素的模式匹配算法,kmp算法和kmp改进算法。
  • 一种新的串模式匹配算法,韩雷钧,张凯,模式的匹配算法一直是计算机搜索领域的研究的重点工程。本文首先分析了传统的蛮力字符串匹配和增强型的Boyer-Moore算法,并提出了一�
  • 算法案例分析—字符串模式匹配算法

    千次阅读 多人点赞 2020-09-09 19:49:13
    今天来和大家分享一个关于字符比较的模式匹配算法,在数据结构中对字符的相关操作中,对子串的定位操作通常称为的模式匹配,同样他也是各种处理中最重要的操作之一,同时子串也称为模式,关于主和模式...

    目录

    一、朴素的模式匹配算法

    二、KMP算法(改进的模式匹配算法)


    hello!大家好哇,我是灰小猿,一个超会写bug的沙雕程序猿!

    今天来和大家分享一个关于字符串比较的模式匹配算法,在数据结构中对字符串的相关操作中,对子串的定位操作通常称为串的模式匹配,同样他也是各种串处理中最重要的操作之一,同时子串也称为模式串,关于主串和模式串的匹配算法常用的主要有两种:朴素的模式匹配算法和KMP算法(改进的模式匹配算法),接下来将分别对这两种算法进行分析。

    一、朴素的模式匹配算法

    朴素的模式匹配算法也被称为布鲁特—福斯算法,其基本思想是:从主串的第一个字符起与模式串的第一个字符相比较,若相等,则逐一对之后的字符进行比较,否则从主串的第二个字符与模式串的第一个字符重新比较,直到模式串中的每一个字符依次与主串中连续的字符序列相匹配为止,这时就称为匹配成功,如果不能在主串中找到与模式串相匹配的内容,则称为匹配失败。

    接下来举一个例子,以字符数组存储字符串,实现朴素的模式匹配算法。

    //传入主串s和模式串t,同时设定从主串中开始匹配的位置pos
    int index(char s[],char t[],int pos) {
    	int i,j,slen,tlen;
    	i = pos;
    	j = 0;
    	slen = s.length;	//获取到主串的长度
    	tlen = t.length;	//获取到模式串的长度
    	while (i<slen && j<tlen) {
    		if (s[i] == t[j]) {
    			i++;
    			j++;
    		}
    		else {
    			i = i-j+1;
    			j=0;
    		}		
    	}
    	if (j>=tlen) {
    		return i-tlen;
    	}
    	return 1;
    }

     

    二、KMP算法(改进的模式匹配算法)

    KMP算法是上一个算法的改进,相比于朴素的模式匹配算法,KMP算法在进行主串和模式串的匹配过程中,每当匹配过程中出现相比较的字符不相等时,不需要回退主串的字符位置指针,而是利用已经得到的“部分匹配”结果将模式串向右“滑动”尽可能远的距离,再继续进行比较。

    设模式串为“P0...P(m-1)”,KMP匹配算法的思想是:当模式串中的字符Pj与主串中相应的字符Si不相等时,因其前j个字符(“P0...P(j-1)”)已经获得了成功的匹配,所以若模式串中的“P0...P(k-1)”与“P(j-k)...P(j-1)”相同,这时可令P0与Si相比较,从而使i无需回退。

    在KMP算法中,依据模式串的next函数值可以实现子串的滑动,若令next[j]=k,则next[j]表示当模式串中的Pj与主串中相应的字符不相等时,令模式串的Pnext[j]与主串的相应字符进行比较,

    关于next函数有如下的定义:

    以下是求模式串的next函数的程序:

    //求模式串p的next函数值,并存入数组next中
    void Get_next(char *p,int next[])
    {
    	int i,j,slen;
    	slen = strlen(p);	//获取到模式串的长度
    	i=0;
    	while (i<slen) {
    		if (j==-1||p[i]==p[j]) {
    			++i;
    			++j;
    			next[i] = j;
    		} else {
    			j = next[j];
    		}
    	}
    }

    在获取到的next函数后,

    在KMP模式匹配算法中,设模式串的第一个字符下标为0,则KMP算法如下:

    /*利用模式串p的next函数,求p在主串s中从第pos个字符开始的位置*/
    /*若匹配成功,返回模式串在主串的位置下标,否则返回-1 */
    int Index_KMP(char *s,char *p,int pos,int next[])
    {
    	int i,j,slen,plen;
    	i=pos-1;
    	j=-1;
    	slen = strlen(s);	//求主串的长度
    	plen = strlen(p);	//求模式串的长度
    	while (i<slen && j<plen) {
    		if (j==-1||s[i]==p[j]) {
    			++i;
    			++j;
    		} else {
    			j=next[j];
    		}
    	}
    	if (j>=plen) {
    		return i-plen;
    	}
    	else {
    		return -1
    	}
    		
    }

    关于字符串模式匹配算法就分享到这里,有不足的地方还希望各位大佬一起指正,

    觉得不错记得点赞关注哟!

    大灰狼陪你一起进步!

    展开全文
  • 数据结构 基于字符串模式匹配算法的病毒感染检测问题实验目的实验内容实验提示 实验目的 1.掌握字符串的顺序存储表示方法。 2.掌握字符串模式匹配算法BF算法或KMP算法的实现。 实验内容 问题描述 医学研究者最近发现...

    数据结构 基于字符串模式匹配算法的病毒感染检测问题

    实验目的

    1.掌握字符串的顺序存储表示方法。
    2.掌握字符串模式匹配算法BF算法或KMP算法的实现。

    实验内容

    问题描述
    医学研究者最近发现了某些新病毒,通过对这些病毒的分析,得知它们的DNA序列都是环状的。
    现在研究者已收集了大量的病毒DNA和人的DNA数据,想快速检测出这些人是否感染了相应的病毒。为了方便研究,研究者将人的DNA和病毒DNA均表示成由一些字母组成的字符串序列,然后检测某种病毒DNA序列是否在患者的DNA序列中出现过,如果出现过,则此人感染了该病毒,否则没有感染。例如,假设病毒的DNA序列为baa,患者1的DNA序列为aaabbba,则感染;患者2的DNA序列为babbba,则未感染。(注意,人的DNA序列是线性的,而病毒的DNA序列是环状的。)
    输入要求
    多组数据,每组数据有1行,为序列A和B, A对应病毒的DNA序列,B对应人的DNA序列。A和B都为“0”时输人结束。
    输出要求
    对于每组数据输出1行,若患者感染了病毒输出“YES",否则输出“NO"。
    输入样例

    abbab abbabaab
    baa cacdvcabacsd
    abc def
    0 0
    

    输出样例

    YES
    YES
    NO
    

    实验提示

    此实验内容即要求实现主教材的案例4.1,具体实现可参考算法4.5。算法4.5是利用BF算法来实现字符串的模式匹配过程的,效率较低,可以利用KMP算法完成模式匹配以提高算法的效率。读者可以模仿算法4.5,利用KMP算法来完成病毒感染检测的方案。

    strlen()函数:求字符串的长度。

    实验代码

    BF算法(C++)

    #include <iostream>
    using namespace std;
    #define MAXSIZE 255
    
    //BF算法
    int Index_BF(char S[], char T[], int pos)//从第0位开始
    {//返回模式T在主串S中第pos个字符开始第一次出现的位置;若不存在,则返回0
    	int i = pos; int j = 0;
    	int lenS = strlen(S);
    	int lenT = strlen(T);
    	while (i < lenS && j < lenT)
    	{
    		if (S[i] == T[j])
    		{
    			i++; j++;
    		}
    		else
    		{
    			i = i - j + 1; j = 0;
    		}
    	}
    	if (j >= lenT)
    		return i- lenT;
    	else
    		return -1;
    }
    
    int main()
    {
    	int pos = 0; int result = 0;
    	char s[MAXSIZE] = {}, t[MAXSIZE] = {};
    	char output[MAXSIZE] = {};
    	while (true)
    	{
    		cin >> s; cin >> t;
    		if (s[0] == '0' && t[0] == '0')
    		{
    			cout << output << endl;
    			break;
    		}
    		result = Index_BF(t, s, pos);
    		if (result == -1)
    		{
    			strcat_s(output, "No\n");//字符串拼接
    		}
    		else
    		{
    			strcat_s(output, "Yes\n");//字符串拼接
    		}
    	}
    }
    

    运行截图
    C++实验截图

    KMP算法(C++)

    #include <iostream>
    using namespace std;
    #define MAXSIZE 50
    int next1[MAXSIZE];
    //报错next不明确是因为和std命名空间冲突了,它作为全局变量不行,所以改成next1
    void get_next(char t[])
    {
    	char t2[MAXSIZE] = { '0' };
    	for (int m = 0; m < MAXSIZE - 1; m++)
    	{
    		t2[m + 1] = t[m];
    		if (t[m] == '\0')
    			break;
    	}
    	int i = 1, j = 0;
    	next1[1] = 0;
    	while (i < strlen(t))
    	{
    		if (j == 0 || t2[i] == t2[j])
    		{
    			i++;
    			j++;
    			next1[i] = j;
    
    		}
    		else
    		{
    			j = next1[j];
    		}
    	}
    }
    
    //KMP算法
    int Index_KMP(char S[], char T[], int pos)//从第0位开始
    {//返回模式T在主串S中第pos个字符开始第一次出现的位置;若不存在,则返回0
    	int i = 1; int j = 1;
    	char s2[MAXSIZE] = { '0' };
    	char t2[MAXSIZE] = { '0' };
    	for (int m = 0; m < MAXSIZE - 1; m++)
    	{
    		t2[m + 1] = T[m];
    		s2[m + 1] = S[m];
    		if (T[m] == '\0')
    			break;
    	}
    	int lenS = strlen(S);
    	int lenT = strlen(T);
    	while (i <= lenS && j <= lenT)
    	{
    		if (j == 0 || s2[i] == t2[j])
    		{
    			i++; j++;
    		}
    		else
    		{
    			//i = i - j + 1; j = 0;
    			j = next1[j];
    		}
    	}
    	if (j > lenT)
    		return i - lenT;
    	else
    		return -1;
    }
    
    int main()
    {
    	int pos = 0; int result = 0;
    	char s[MAXSIZE] = {}, t[MAXSIZE] = {};
    	char output[MAXSIZE] = {};
    
    	while (true)
    	{
    		cin >> s; cin >> t;
    		if (s[0] == '0' && t[0] == '0')
    		{
    			cout << output << endl;
    			break;
    		}
    		get_next(t);
    		result = Index_KMP(t, s, pos);
    		if (result == -1)
    		{
    			//cout << "No" << endl;
    			strcat_s(output, "No\n");
    		}
    		else
    		{
    			//cout << "Yes" << endl;
    			strcat_s(output, "Yes\n");
    		}
    	}
    }
    

    运行截图
    KMP C++

    KMP算法(Python)

    #KMP算法
    def get_next(t1, next):
        i,j=1,0
        next[1]=0
        while i<len(t1):
            if (j==0 or t1[i]==t1[j]):
                i+=1
                j+=1
                next[i]=j
            else:
                j=next[j]
        #next = next[0:len(t1)]
        return next
                    
    
    def Index_KMP(S,T):
        i,j=1,1
        while(i<=len(S)-1 and j<=len(T)-1):
            if(j==0 or S[i]==T[j]):
                #print(S[i],T[j])
                i += 1
                j += 1
            else:
                j=next[j]
                #print(next[j])
        if j>=len(T)-1:
            return i-len(T)
        else:
            return -1
    
    
    next = 50 *[0]
    needPrint = ""
    while True:
        a,b = map(str,input().split())
        if a=='0' and b=='0':
            print(needPrint)
            break
        a0=list(a)
        b0=list(b)
        a1=['0']
        b1=['0']
        a=a1+a0
        b=b1+b0
        next = get_next(a, next)
        ans = Index_KMP(b,a)
        if ans>=0:
            needPrint += "Yes\n"
        else:
            needPrint += "No\n"
    

    运行截图
    python运行截图

    实验小结

    实际上,严蔚民实验书上,第二个结果应该是Yes,可能是因为病毒是环状的吧。
    可是我个人觉得,基于环状的情况下,baa可以等同aab,但要是等同于aba就有点奇怪了。所以我就按传统的BF和KMP算法来实现了。

    展开全文
  • 关于KMP_字符串模式匹配算法的教学课件,详细讲解了Kmp 的原理与不足和改进
  • 用C++实现BM的字符串模式匹配算法,两个代码分别实现坏字符规则和好后缀规则
  • 在主S中找 是否有与模式串T相等的 int next[100] = {}; get_next(T, next); int length_S = strlen(S)-1; int length_T = strlen(T)-1; int i = 1, j = 1; while (i ) { if (j == 0 || S[i] == T[j]) { i++, j++...

    头文件(tou.h):

    void get_next(char T[], int next[]);
    
    int Index_KMP(char S[], char T[]);
    
    void move1(char a[]);
    
    void transform(char a[]);
    
    void Judge(char S[], char T[]);
    
    void gcd(char a[]);

    头文件中函数的实现(tou.cpp):

    #define _CRT_SECURE_NO_WARNINGS  
    #include<stdio.h>
    #include<string.h>
    #include"tou.h"
    
    void move1(char a[]) {      //将数组a整体向后移动一位,让a[0]失效
    	for (int i = strlen(a); i > 0; i--) {
    		a[i] = a[i - 1];
    	}
    }
    
    void transform(char a[]) {  //将数组头(a[1])调到数组尾,数组整体向前进一位
    	int length = strlen(a)-1;
    	char head = a[1];
    	for (int i = 1; i < length; i++) {
    		a[i] = a[i + 1];
    	}
    	a[length] = head;
    }
    
    void gcd(char a[]) {       //颠倒数组元素的顺序(数组下标从1开始)
    	int length = strlen(a) - 1;
    	for (int i = 1; i < 1 + length / 2; i++) {
    		char temp = a[i];
    		a[i] = a[length + 1 - i];
    		a[length + 1 - i] = temp;
    	}
    }
    
    void get_next(char T[], int next[]) {    //根据模式串设置好next[]数组中对应的值
    	int length_T = strlen(T)-1;
    	int i = 1, j = 0;
    	next[1] = 0;
    	while (i < length_T) {
    		if (j == 0 || T[i] == T[j]) {
    			i++, j++;
    			next[i] = j;
    		}
    		else
    			j = next[j];
    	}
    }
    
    int Index_KMP(char S[], char T[]) {    //KMP算法。在主串S中找 是否有与模式串T相等的串
    	int next[100] = {};
    	get_next(T, next);     
    
    	int length_S = strlen(S)-1;
    	int length_T = strlen(T)-1;
    	int i = 1, j = 1;
    
    	while (i <= length_S && j <= length_T) {
    		if (j == 0 || S[i] == T[j]) {
    			i++, j++;
    		}
    		else j = next[j];
    	}
    	if (j > length_T) return 1;
    	else return 0;
    }
    
    void Judge(char S[], char T[]) {      //判断人DNA是否感染环状病毒DNA
    	int length_T = strlen(T) - 1;
    	int i = length_T;
    	while (i) {
    		transform(T);
    		if(Index_KMP(S,T)) break;
    		gcd(T);                       //颠倒模式串重新判断
    		if (Index_KMP(S, T)) break; 
    		gcd(T);                       //恢复模式串
    		i--;
    	}
    	if (i) printf("是否感染:YES");
    	else printf("是否感染:NO");
    }

    主函数(ceshi1.cpp):

    #define _CRT_SECURE_NO_WARNINGS   
    #include<stdio.h>
    #include<string.h>
    #include"tou.h"
    
    int main() {
    	while (1) {
    		char T[100] = {};     //模式串(病毒DNA)
    		char S[100] = {};     //主串(人DNA)
    
    		printf("请输入 病毒的DNA序列 和 人的DNA序列:\n");
    		scanf("%s%s", T, S);
    
    		if (T[0] == '0' && S[0] == '0') break;   //结束条件
    
    		move1(S), move1(T);
    
    		Judge(S, T);
    		printf("\n\n");
    	}
    	return 0;
    }

    测试结果:

    展开全文
  • 实验四 基于字符串模式匹配算法的病毒感染检测 【实验目的】 1.掌握字符串的顺序存储表示方法。 2.掌握字符串模式匹配BF算法和KMP算法的实现。 【实验内容】 问题描述 医学研究者最近发现了某些新病毒,通过对这些...

    实验四 基于字符串模式匹配算法的病毒感染检测

    【实验目的】
    1.掌握字符串的顺序存储表示方法。
    2.掌握字符串模式匹配BF算法和KMP算法的实现。
    【实验内容】
    问题描述
    医学研究者最近发现了某些新病毒,通过对这些病毒的分析,得知它们的DNA序列都是环状的。现在研究者已收集了大量的病毒DNA和人的DNA数据,想快速检测出这些人是否感染了相应的病毒。为了方便研究,研究者将人的DNA和病毒DNA均表示成由一些字母组成的字符序列,然后检测某种病毒DNA序列是否在患者的DNA序列中出现过。如果出现过,则此人感染了该病毒,否则没有感染。例如,假设病毒的DNA序列为baa,患者1的DNA序列为aaabbba,则感染;患者2的DNA序列为babbba,则未感染。(注意,人的DNA序列是线性的,而病毒的DNA序列是环状的。)
    输入要求
    多组数据,每组数据有1行,为序列A和B,A对应病毒的DNA序列,B对应人的DNA序列。A和B都为“0”时输入结束。
    输入样例
    abbab abbabaab
    baa cacdvcabacsd
    abc def
    0 0
    输出样例
    YES
    YES
    NO
    【实验提示】
    此实验内容即要求实现教材算法的具体案例。利用BF算法来实现字符串的模式匹配过程的,效率较低,。利用KMP算法完成模式匹配以提高算法的效率。

    解决方法1:暴力算法

    #include <stdio.h>  // printf(); scanf()
    #include <stdlib.h> // exit()
    #include <malloc.h> // malloc()
    #include <time.h>   // srand((unsigned)time(NULL));
    #include <string.h>
     
    
    #define TRUE    1
    #define FALSE   0
    #define OK      1
    #define ERROR   0
    
    typedef int Status;
     
    typedef int ElemType;
    
    
    
    #define MAXSTRLEN 255                           
    typedef unsigned char SString[MAXSTRLEN + 1];   
    
    
    Status StrAssign(SString &T, char *chars) {
    	if(strlen(chars) > MAXSTRLEN)
    		return ERROR;
    	else {
    		T[0] = strlen(chars);      
    		for(int i=1; i<=T[0]; i++)
    			T[i] = *(chars+i-1);
    		return OK;
    	}
    }
    
    
    Status StrCopy(SString &T, SString S) {
    	for(int i=0; i<=S[0]; i++)
    		T[i] = S[i];
    	return OK;
    }
    
    
    int StrLength(SString S) {
    	return S[0];
    }
    
    
    
    
    int index(SString S,SString T,int pos)
    {
    	int i=pos,j=1;
    	while(i<=S[0]&&j<=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;
     } 
    
    int main()
    {	
    		int flag[100];
    		int w=0; 
    		int x;int number;int pos;
    	char  c[MAXSTRLEN+1],d[MAXSTRLEN+1];
    	SString S;
    	SString T;
    	SString Z;
    	
    	do
    	{
    		
    	scanf("%s",c);
    	scanf("%s",d);
    	
    		
    		StrAssign(S, c);
    
    	StrAssign(T, d);
    	
    	char str[T[0]];
    	
    	 for(int i=0; i<=S[0]; i++)
    		str[i] = T[i+1];
    		
    	
    	int i=0;
    	Z[0]=T[0];
    	for(i=0;i<T[0];i++)
    	{
    		for(int j=1;j<=T[0];j++)
    		{
    		Z[j]=str[(j+i)%(T[0])];	
    		}
    	
    	number=index(S,Z,pos);
    	if(number!=0&&strcmp(c,"0")!=0&&strcmp(d,"0")!=0)
    	{
    		flag[w++]=1;
    		break; 
    	} 
    	 
    	 
    	}
    	 if(i==T[0]&&strcmp(c,"0")!=0&&strcmp(d,"0")!=0)
    	 flag[w++]=0;
    	
    	}while(strcmp(c,"0")!=0&&strcmp(d,"0")!=0);
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	for(int e=0;e<w;e++)
    	{
    		if(flag[e]==1)
    		printf("YES\n");//即在人体dna中找到与病毒dna相同的序列 
    		else
    		printf("NO\n");//即在人体dna中找到与病毒dna相同的序列 
    	}	
    	
    			
    
    
    	
    		
    		
    	
    	
    	
    		
    	 
    	 return 0;
    		
    }
    

    解决方法2:kmp算法

    #include <stdio.h>  // printf(); scanf()
    #include <stdlib.h> // exit()
    #include <malloc.h> // malloc()
    #include <time.h>   // srand((unsigned)time(NULL));
    #include <string.h>
     
    #define TRUE    1
    #define FALSE   0
    #define OK      1
    #define ERROR   0
    
    typedef int Status;
    typedef int ElemType;
    #define MAXSTRLEN 255                         
    typedef unsigned char SString[MAXSTRLEN + 1];
    
    
    Status StrAssign(SString &T, char *chars) {
    	if(strlen(chars) > MAXSTRLEN)
    		return ERROR;
    	else {
    		T[0] = strlen(chars);       // 0号单元存放串的长度
    		for(int i=1; i<=T[0]; i++)
    			T[i] = *(chars+i-1);
    		return OK;
    	}
    }
    
    
    Status StrCopy(SString &T, SString S) {
    	for(int i=0; i<=S[0]; i++)
    		T[i] = S[i];
    	return OK;
    }
    
    
    int StrLength(SString S) {
    	return S[0];
    }
    
    void get_next(SString T,int next[])
    {
    	int j; 
    	int i=1;next[1]=0;j=0;
    	while(i<T[0])
    	{
    		if(j==0||T[i]==T[j]){i++;j++;next[i]=j;}
    		else j=next[j];
    		
    	}
    }
    
    int Index_KMP(SString S,SString T,int pos)
    {	
    
    	int next[MAXSTRLEN+1]; 
    	get_next(T,next);
    	int i=pos;  int j=1;
    	while(i<=S[0]&&j<=T[0])//i j都不超过其串的长度
    	 
    	{//失配 
    		//1:失配,当j==0时,则目标主串的检测指针前进一位,模式串检测指针回到T[1].进行下一趟的比较
    		
    		//2:失配,当j>0时,那么在下一趟比较时,模式串的起始位置为Tnext[j],目标主串S的检测指针不回溯,仍然指向上一趟失配的位置 
    		
    		if(j==0||S[i]==T[j])
    		{
    			++i;++j;//继续比较后继字符 
    		}
    		else j=next[j];//模式串向右移动 
    		
    		
    	}
    	
    	if(j>T[0]) return i-T[0];//匹配成功 
    	else return 0;
    }
    
    int main()
    {	
    		int flag[100];
    		int w=0; 
    		int x;int number;int pos;
    	char  c[MAXSTRLEN+1],d[MAXSTRLEN+1];
    	SString S;
    	SString T;
    	SString Z;
    	
    	do
    	{
    	scanf("%s",d);	
    	scanf("%s",c);
    
    	
    		
    		StrAssign(S, c);
    
    	StrAssign(T, d);
    	
    	char str[T[0]];
    	
    	 for(int i=0; i<=S[0]; i++)
    		str[i] = T[i+1];
    		
    	
    	int i=0;
    	Z[0]=T[0];
    	for(i=0;i<T[0];i++)
    	{
    		for(int j=1;j<=T[0];j++)
    		{
    		Z[j]=str[(j+i)%(T[0])];	
    		}
    		//StrPrint(Z); 
    		//printf("\n");
    	number=Index_KMP(S,Z,pos);
    	if(number!=0&&strcmp(c,"0")!=0&&strcmp(d,"0")!=0)
    	{
    		flag[w++]=1;
    		break; 
    	} 
    	 
    	 
    	}
    	 if(i==T[0]&&strcmp(c,"0")!=0&&strcmp(d,"0")!=0)
    	 flag[w++]=0;
    	
    	}while(strcmp(c,"0")!=0&&strcmp(d,"0")!=0);
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	for(int e=0;e<w;e++)
    	{
    		if(flag[e]==1)
    		printf("YES\n");//即在人体dna中找到与病毒dna相同的序列 
    		else
    		printf("NO\n");//即在人体dna中找到与病毒dna相同的序列 
    	}	
    	
    			
    
    
    	
    		
    		
    	
    	
    	
    		
    	 
    	 return 0;
    		
    }
    解决方法3:kmp算法改进版
    
    ```c
    #include <stdio.h>  // printf(); scanf()
    #include <stdlib.h> // exit()
    #include <malloc.h> // malloc()
    #include <time.h>   // srand((unsigned)time(NULL));
    #include <string.h>
     
    
    #define TRUE    1
    #define FALSE   0
    #define OK      1
    #define ERROR   0
    typedef int Status;
    typedef int ElemType;
    #define MAXSTRLEN 255                         
    typedef unsigned char SString[MAXSTRLEN + 1];   
    
    
    Status StrAssign(SString &T, char *chars) {
    	if(strlen(chars) > MAXSTRLEN)
    		return ERROR;
    	else {
    		T[0] = strlen(chars);       
    		for(int i=1; i<=T[0]; i++)
    			T[i] = *(chars+i-1);
    		return OK;
    	}
    }
    
    int StrLength(SString S) {
    	return S[0];
    }
    
    void get_nextval(SString T,int nextval[])
    {
    	int j; 
    	int i=1;nextval[1]=0;j=0;
    	while(i<T[0])
    	{
    		if(j==0||T[i]==T[j])
    		{i++;j++;
    		
    		if(T[i]!=T[j])
    			nextval[i]=j;
    		 
    		 else 
    		 	nextval[i]=nextval[j];
    		
    		}
    		else j=nextval[j];
    		
    	}
    }
    
    
    int Index_KMP_val(SString S,SString T,int pos)
    {	
    
    	int nextval[MAXSTRLEN+1]; 
    	get_nextval(T,nextval);
    	int i=pos;  int j=1;
    	while(i<=S[0]&&j<=T[0])//i j都不超过其串的长度
    	 
    	{//失配 
    		//1:失配,当j==0时,则目标主串的检测指针前进一位,模式串检测指针回到T[1].进行下一趟的比较
    		
    		//2:失配,当j>0时,那么在下一趟比较时,模式串的起始位置为Tnext[j],目标主串S的检测指针不回溯,仍然指向上一趟失配的位置 
    		
    		if(j==0||S[i]==T[j])
    		{
    			++i;++j;//继续比较后继字符 
    		}
    		else j=nextval[j];//模式串向右移动 
    		
    		
    	}
    	
    	if(j>T[0]) return i-T[0];//匹配成功 
    	else return 0;
    }
    
    int main()
    {	
    		int flag[100];//用于计算循环数组  每次的结果 
    		int w=0; //用于统计flag数组 
    		int x;int number;int pos;
    	char  c[MAXSTRLEN+1],d[MAXSTRLEN+1];
    	SString S;
    	SString T;
    	SString Z;
    	
    	do
    	{
    	scanf("%s",d);	
    	scanf("%s",c);
    
    	
    		
    		StrAssign(S, c);
    
    	StrAssign(T, d);
    	
    	char str[T[0]];
    	
    	 for(int i=0; i<=S[0]; i++)
    		str[i] = T[i+1];
    		
    	
    	int i=0;
    	Z[0]=T[0];
    	for(i=0;i<T[0];i++)
    	{
    		for(int j=1;j<=T[0];j++)
    		{
    		Z[j]=str[(j+i)%(T[0])];	
    		}
    	number=Index_KMP_val(S,Z,pos);
    	if(number!=0&&strcmp(c,"0")!=0&&strcmp(d,"0")!=0)
    	{
    		flag[w++]=1;
    		break; 
    	} 
    	 
    	 
    	}
    	 if(i==T[0]&&strcmp(c,"0")!=0&&strcmp(d,"0")!=0)
    	 flag[w++]=0;
    	
    	}while(strcmp(c,"0")!=0&&strcmp(d,"0")!=0);
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	for(int e=0;e<w;e++)
    	{
    		if(flag[e]==1)
    		printf("YES\n");//即在人体dna中找到与病毒dna相同的序列 
    		else
    		printf("NO\n");//即在人体dna中找到与病毒dna相同的序列 
    	}	
    	
    			
    
    
    	
    		
    		
    	
    	
    	
    		
    	 
    	 return 0;
    		
    }
    

    在这里插入图片描述

    展开全文
  • 从主中第K个字符起,求出子串在主中首次出现的位置,即模式匹配或匹配。  朴素的模式匹配算法(BF算法)  KMP改进算法(Next[ ])  KMP改进算法(NextVal[ ])
  • 基于FPGA设计一个能够检测出重叠...首先从KMP字符串模式匹配算法出发,推导出next函数值与序列检测器状态之间的关系,并针对匹配串重叠的情况进行修改,得到有限状态机的状态转换图,最后用VHDL语言描述并仿真验证。
  • 字符串模式匹配算法的 Java 实现

    千次阅读 2019-02-21 20:28:39
    字符串匹配算法:检查模式P是否另一个字符T(T代表文本)的子串,因为要检查整个定长的字符P,所以有时这些算法称为精确字符串匹配算法。 蛮力法(BF算法) 对于文本T中的每个可能的位置,检查P是否匹配,...
  • 多字符串模式匹配算法。 该实现受到启发 入门 modelA = mspm.NewModel("mspm_model_A") patternsToSearch = strings.NewReader(words) // words is newline seperated list of words/keywords // build mspm model...
  • 基于BF和KMP的串模式匹配算法设计与实现(C语言)
  • 模式匹配算法,通俗地理解,是一种用来判断两个之间是否具有"主与子串"关系的算法。 主与子串:如果 A(如 "shujujiegou")中包含有 B(如 "ju"),则称 A 为主 B 为子。主与子串之间的...
  • 基于BF和KMP的串模式匹配算法设计与实现(C语言).rar
  • KMP算法是字符串模式匹配算法中较为高效的算法之一,其在某次子串匹配母串失败时并未回溯母串的指针而是将子串的指针移动到相应的位置。严蔚敏老师的书中详细描述了KMP算法,同时前面的例子中也描述了子串移动位置的...
  • KMP字符串模式匹配算法[文].pdf
  • 一种改进的模式匹配算法的探讨,穆维友,吴泽平,模式匹配算法一直都是计算机科学领域的研究焦点之一。本文首先分析了BF、KMP、BM三种算法,并提出了一种改进的Sundaynew算法,给��
  • KMP算法是字符串模式匹配算法中较为高效的算法之一,其在某次子串匹配母串失败时并未回溯母串的指针而是将子串的指针移动到相应的位置。严蔚敏老师的书中详细描述了KMP算法,同时前面的例子中也描述了子串移动位置的...
  • 字符模式匹配算法——KMP的C++实现。
  • KMP字符串模式匹配算法

    千次阅读 2016-09-23 11:39:07
    KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。 一.简单匹配算法 先来看一个简单匹配算法的函数: ...
  • 这是重庆大学数据结构实验报告,题目是的操作与KMP模式匹配算法。里面有完整的实验流程,包括源码及结果截屏
  • 《KMP字符串模式匹配算法》教学课例[参照].pdf
  • 《KMP字符串模式匹配算法》教学课例[归纳].pdf
  • 串模式匹配算法的几种代码实现

    千次阅读 2015-07-31 12:05:40
    c语言中字符处理的库函数还是比较全的,c++里的string类就更不用说了。有些处理函数虽然已封装为库函数,直接调用即可,但是正在学习数据结构,还是想敲些代码,以便总结+巩固。 首先,总结一下常用的c语言中字符...
  • HDUOJ 1634 算法4-6:KMP字符串模式匹配算法实现 题目链接 题目描述 KMP算法是字符串模式匹配算法中较为高效的算法之一,其在某次子串匹配母串失败时并未回溯母串的指针而是将子串的指针移动到相应的位置。严蔚敏...
  • 解析BF(普通串模式匹配算法)算法

    千次阅读 2020-10-14 14:11:15
    写在前面:博主是一位普普通通的19届二本大学生,平时最大的爱好就是听听歌,逛逛B站。博主很喜欢的一句话花开堪折直须折,莫待无花空折枝:博主的理解是头一次为人,就应该做自己想做的事,做自己... 2.BF算法代码实.
  • 模式匹配算法,通俗地理解,是一种用来判断两个之间是否具有"主与子串"关系的算法。 主与子串:如果 A(如 "shujujiegou")中包含有 B(如 "ju"),则称 A 为主 B 为子。主与子串之间的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,188
精华内容 44,875
关键字:

串的模式匹配算法