串的模式匹配算法实验报告
- 格式:docx
- 大小:34.84 KB
- 文档页数:17
【精品】数据结构串实验报告
(仅校内可用)
本次实验是基于数据结构串的相关知识,设计、实现及实验关于串的操作,并要求我们编写综合性实验报告。
1、实验目的是了解串结构及其实现方法,并能够用有限的时间内完成实验。
2、实验要求:
(1)实现关于串的一组基本操作
(2)实现串的模式匹配算法
3、实验的进度:
(1)完成程序的设计,要求建立合理的数据结构,编写部分重要算法,调试程序;
(2)设计一组完整的数据,并完成所设计程序的测试;
(3)对串模式匹配算法和高效率算法的效率、正确性进行测试;
(4)完成实验总结,参加试验验收。
4、实验结果:
(1)建立了串的节点数据结构,并编写相关操作算法,经测试结果显示,程序的实现能做到正确、有效的运行;
(2)完成对串模式匹配算法和高效率算法的测试,匹配算法水平介于暴力及KMP算法之间,效率较高;高效率算法在重复部分采用滑动窗口技术,同时避免了重复移动结点带来的时间开销,效率较高且正确性得到了优化;
(3)完成了实验总结,并得出本次实验的结论:实现串的模式匹配算法和高效率算法能够较好地实现串的基本操作,同时具有较高的效率;
最后,在实验过程中,我收获颇丰,加深了对串结构及实现方法的理解,使我对数据结构有了更全面的认识。
串的模式匹配问题实验总结(用C实现)第一篇:串的模式匹配问题实验总结(用C实现)串的模式匹配问题实验总结1实验题目:实现Index(S,T,pos)函数。
其中,Index(S,T,pos)为串T在串S的第pos个字符后第一次出现的位置。
2实验目的:熟练掌握串模式匹配算法。
3实验方法:分别用朴素模式匹配和KMP快速模式匹配来实现串的模式匹配问题。
具体方法如下:朴素模式匹配:输入两个字符串,主串S和子串T,从S串的第pos个位置开始与T的第一个位置比较,若不同执行i=i-j+2;j=1两个语句;若相同,则执行语句++i;++j;一直比较完毕为止,若S中有与T相同的部分则返回主串(S字符串)和子串(T字符串)相匹配时第一次出现的位置,若没有就返回0。
KMP快速模式匹配:构造函数get_next(char *T,int *next),求出主串S串中各个字符的next值,然后在Index_KMP(char *S,char *T,int pos)函数中调用get_next(char *T,int *next)函数并调用next值,从S串的第pos 位置开始与T的第一个位置进行比较,若两者相等或j位置的字符next值等于0,则进行语句++i;++j;即一直向下进行。
否则,执行语句j=A[j];直到比较完毕为止。
若S中有与T相同的部分则返回主串(S字符串)和子串(T字符串)相匹配时第一次出现的位置,若没有就返回04实验过程与结果:(1)、选择1功能“输入主串、子串和匹配起始位置”,输入主串S:asdfghjkl, 输入子串T:gh,输入pos的值为:2。
选择2功能“朴素的模式匹配算法”,输出结果为 5;选择3功能“KMP快速模式匹配算法”,输出结果为 5;选择0功能,退出程序。
截图如下:(2)、选择1功能“输入主串、子串和匹配起始位置”,输入主串S:asdfghjkl, 输入子串T:wp, 输入pos的值为:2。
实验三串的模式匹配⼀、实验⽬的1、了解串的基本概念2、掌握串的模式匹配算法的实现⼆、实验预习说明以下概念1、模式匹配:数据结构中字符串的⼀种基本运算,给定⼀个⼦串,要求在某个字符串中找出与该⼦串相同的所有⼦串。
2、BF算法:BF算法,即暴⼒(Brute Force)算法,是普通的模式匹配算法,BF算法的思想就是将⽬标串S的第⼀个字符与模式串T的第⼀个字符进⾏匹配,若相等,则继续⽐较S的第⼆个字符和 T的第⼆个字符;若不相等,则⽐较S的第⼆个字符和T的第⼀个字符,依次⽐较下去,直到得出最后的匹配结果。
BF算法是⼀种蛮⼒算法。
3、KMP算法:KMP算法是⼀种改进的字符串匹配算法,KMP算法的核⼼是利⽤匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的⽬的。
具体实现就是通过⼀个next()函数实现,函数本⾝包含了模式串的局部匹配信息。
三、实验内容和要求1、阅读并运⾏下⾯程序,根据输⼊写出运⾏结果。
#include<stdio.h>#include<string.h>#define MAXSIZE 100typedef struct{char data[MAXSIZE];int length;}SqString;int strCompare(SqString *s1,SqString *s2); /*串的⽐较*/void show_strCompare();void strSub(SqString *s,int start,int sublen,SqString *sub);/*求⼦串*/void show_subString();int strCompare(SqString *s1,SqString *s2){int i;for(i=0;i<s1->length&&i<s2->length;i++)if(s1->data[i]!=s2->data[i])return s1->data[i]-s2->data[i];return s1->length-s2->length;}void show_strCompare(){SqString s1,s2;int k;printf("\n***show Compare***\n");printf("input string s1:");gets(s1.data);s1.length=strlen(s1.data);printf("input string s2:");gets(s2.data);s2.length=strlen(s2.data);if((k=strCompare(&s1,&s2))==0)printf("s1=s2\n");else if(k<0)printf("s1<s2\n");elseprintf("s1>s2\n");printf("\n***show over***\n");}void strSub(SqString *s,int start,int sublen,SqString *sub){int i;if(start<1||start>s->length||sublen>s->length-start+1){sub->length=0;}for(i=0;i<sublen;i++)sub->data[i]=s->data[start+i-1];sub->length=sublen;}void show_subString(){SqString s,sub;int start,sublen,i;printf("\n***show subString***\n");printf("input string s:");gets(s.data);s.length=strlen(s.data);printf("input start:");scanf("%d",&start);printf("input sublen:");scanf("%d",&sublen);strSub(&s,start,sublen,&sub);if(sub.length==0)printf("ERROR!\n");else{printf("subString is :");for(i=0;i<sublen;i++)printf("%c",sub.data[i]);}printf("\n***show over***\n");}int main(){int n;do {printf("\n---String---\n");printf("1. strCompare\n");printf("2. subString\n");printf("0. EXIT\n");printf("\ninput choice:");scanf("%d",&n);getchar();switch(n){case 1:show_strCompare();break;case 2:show_subString();break;default:n=0;break;}}while(n);return 0;}运⾏程序输⼊:1studentstudents2Computer Data Stuctures104运⾏结果:2、实现串的模式匹配算法。
实验四:KMP算法实验报告一、问题描述模式匹配两个串。
二、设计思想这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KM P算法。
注意到这是一个改进的算法,所以有必要把原来的模式匹配算法拿出来,其实理解的关键就在这里,一般的匹配算法:int Index(String S,String T,int pos)//参考《数据结构》中的程序{i=pos;j=1;//这里的串的第1个元素下标是1while(i<=S.Length && j<=T.Length){if(S[i]==T[j]){++i;++j;}else{i=i-j+2;j=1;}//**************(1)}if(j>T.Length) return i-T.Length;//匹配成功else return 0;}匹配的过程非常清晰,关键是当‘失配’的时候程序是如何处理的?为什么要回溯,看下面的例子:S:aaaaabababcaaa T:ababcaaaaabababcaaaababc.(.表示前一个已经失配)回溯的结果就是aaaaabababcaaaa.(babc)如果不回溯就是aaaaabababcaaaaba.bc这样就漏了一个可能匹配成功的情况aaaaabababcaaaababc这是由T串本身的性质决定的,是因为T串本身有前后'部分匹配'的性质。
如果T为a bcdef这样的,大没有回溯的必要。
改进的地方也就是这里,我们从T串本身出发,事先就找准了T自身前后部分匹配的位置,那就可以改进算法。
如果不用回溯,那T串下一个位置从哪里开始呢?还是上面那个例子,T为ababc,如果c失配,那就可以往前移到aba最后一个a的位置,像这样:...ababd...ababc->ababc这样i不用回溯,j跳到前2个位置,继续匹配的过程,这就是KMP算法所在。
竭诚为您提供优质文档/双击可除串的模式匹配算法实验报告篇一:串的模式匹配算法串的匹配算法——bruteForce(bF)算法匹配模式的定义设有主串s和子串T,子串T的定位就是要在主串s中找到一个与子串T相等的子串。
通常把主串s称为目标串,把子串T称为模式串,因此定位也称作模式匹配。
模式匹配成功是指在目标串s中找到一个模式串T;不成功则指目标串s中不存在模式串T。
bF算法brute-Force算法简称为bF算法,其基本思路是:从目标串s的第一个字符开始和模式串T中的第一个字符比较,若相等,则继续逐个比较后续的字符;否则从目标串s的第二个字符开始重新与模式串T的第一个字符进行比较。
以此类推,若从模式串T的第i个字符开始,每个字符依次和目标串s中的对应字符相等,则匹配成功,该算法返回i;否则,匹配失败,算法返回0。
实现代码如下:/*返回子串T在主串s中第pos个字符之后的位置。
若不存在,则函数返回值为0./*T非空。
intindex(strings,stringT,intpos){inti=pos;//用于主串s中当前位置下标,若pos不为1则从pos位置开始匹配intj=1;//j用于子串T中当前位置下标值while(i j=1;}if(j>T[0])returni-T[0];elsereturn0;}}bF算法的时间复杂度若n为主串长度,m为子串长度则最好的情况是:一配就中,只比较了m次。
最坏的情况是:主串前面n-m个位置都部分匹配到子串的最后一位,即这n-m位比较了m次,最后m位也各比较了一次,还要加上m,所以总次数为:(n-m)*m+m=(n-m+1)*m从最好到最坏情况统计总的比较次数,然后取平均,得到一般情况是o(n+m).篇二:数据结构实验报告-串实验四串【实验目的】1、掌握串的存储表示及基本操作;2、掌握串的两种模式匹配算法:bF和Kmp。
3、了解串的应用。
【实验学时】2学时【实验预习】回答以下问题:1、串和子串的定义串的定义:串是由零个或多个任意字符组成的有限序列。
kmp算法实验报告篇一:模式匹配KMP算法实验报告实验四:KMP算法实验报告一、问题描述模式匹配两个串。
二、设计思想这种由,注意到这是一个改进的算法,所以有必要把原来的模式匹配算法拿出来,其实理解的关键就在这里,一般的匹配算法:int Index(String S,String T,int pos)//参考《数据结构》中的程序 {i=pos;j=1;//这里的串的第1个元素下标是1while(i {if(S[i]==T[j]){++i;++j;}else{i=i-j+2;j=1;}//**************(1)}if(j>T.Length) return i-T.Length;//匹配成功else return 0;}匹配的过程非常清晰,关键是当‘失配’的时候程序是如何处理的?为什么要回溯,看下面的例子:S:aaaaabababcaaa T:ababcaaaaabababcaaaababc.(.表示前一个已经失配)回溯的结果就是aaaaabababcaaaa.(babc)如果不回溯就是aaaaabababcaaaaba.bc这样就漏了一个可能匹配成功的情况aaaaabababcaaaababc这是由T串本身的性质决定的,是因为T串本身有前后'部分匹配'的性质。
如果T为abcdef这样的,大没有回溯的必要。
改进的地方也就是这里,我们从T串本身出发,事先就找准了T自身前后部分匹配的位置,那就可以改进算法。
如果不用回溯,那T串下一个位置从哪里开始呢?还是上面那个例子,T为ababc,如果c失配,那就可以往前移到aba最后一个a的位置,像这样:...ababd...ababc->ababc这样i不用回溯,j跳到前2个位置,继续匹配的过程,这就是KMP算法所在。
这个当T[j]失配后,j应该往前跳的值就是j的next值,它是由T串本身固有决定的,与S串无关。
《数据结构》上给了next值的定义:0如果j=1next[j]={Max{k|1 1其它情况其实它就是描述前面表述的情况,关于next[1]=0是规定的,这样规定可以使程序简单一些,如果非要定为其它的值只要不和后面的值冲突也是可以的;而那个Max是什么意思,举个例子:T:aaab...aaaab...aaab->aaab->aaab->aaab像这样的T,前面自身部分匹配的部分不止两个,那应该往前跳到第几个呢?最近的一个,也就是说尽可能的向右滑移最短的长度。
一、实验目的1. 理解串匹配算法的基本原理和实现方法。
2. 掌握KMP算法和朴素算法的原理和实现过程。
3. 通过实验对比分析两种算法的性能,验证算法的效率和适用场景。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 开发工具:PyCharm三、实验内容1. 串匹配算法的原理介绍2. 朴素算法的实现与测试3. KMP算法的实现与测试4. 两种算法的性能对比四、实验步骤1. 串匹配算法的原理介绍串匹配算法是指在一个文本串中查找一个模式串的位置。
常用的串匹配算法有朴素算法和KMP算法。
(1)朴素算法(Brute-Force算法):通过逐个字符比较主串和待匹配串,如果匹配成功,则返回匹配位置;如果匹配失败,则回溯到主串上的一个新位置,并在待匹配串上从头开始比较。
(2)KMP算法:通过构建一个部分匹配表(next数组),记录模式串中每个位置对应的最长相同前缀后缀的长度。
在匹配过程中,当出现不匹配时,通过查阅next数组确定子串指针回退位置,从而避免重复比较。
2. 朴素算法的实现与测试(1)实现朴素算法```pythondef brute_force_search(text, pattern):n = len(text)m = len(pattern)for i in range(n - m + 1):j = 0while j < m:if text[i + j] != pattern[j]:breakj += 1if j == m:return ireturn -1```(2)测试朴素算法```pythontext = "ABABDABACDABABCABAB"pattern = "ABABCABAB"print(brute_force_search(text, pattern)) # 输出:10 ```3. KMP算法的实现与测试(1)实现KMP算法```pythondef kmp_search(text, pattern):def build_next(pattern):next_array = [0] len(pattern)k = 0for i in range(1, len(pattern)):while k > 0 and pattern[k] != pattern[i]: k = next_array[k - 1]if pattern[k] == pattern[i]:k += 1next_array[i] = kreturn next_arrayn = len(text)m = len(pattern)next_array = build_next(pattern)k = 0for i in range(n):while k > 0 and text[i] != pattern[k]:k = next_array[k - 1]if text[i] == pattern[k]:k += 1if k == m:return i - m + 1return -1```(2)测试KMP算法```pythontext = "ABABDABACDABABCABAB"pattern = "ABABCABAB"print(kmp_search(text, pattern)) # 输出:10```4. 两种算法的性能对比为了对比两种算法的性能,我们分别测试了不同的文本串和模式串长度,并记录了运行时间。
实验题目:串的模式匹配一、实验目的1、加深理解串的基本操作;2、理解并实现串的朴素模式匹配算法。
二、实验内容输入主串S和模式T,在S中查找T出现的第一个位置。
三、设计与编码1、基本思想1,在串S和串T中设置比较的起始下标i和j;2,如果S[i]=T[j],继续比较S和T的下一对字符,否则将下标i,j回溯,准备下一趟比较;3,如果T中所有字符都比较完,则匹配成功,返回匹配的开始位置,否则返回0;2、编码#include<iostream>#include<string>using namespace std;class BF{private:char *s,*t;public:BF(char a[],char b[]){s=a;t=b;}int bf(){int i=0,j=0;while((s[i]!='\0')&&(t[j]!='\0')){if(s[i]==t[j]){i++;j++;}else{i=i-j+1;j=0;}}if(t[j]=='\0')return i-j+1;}};int main(){char s[100],t[100];cin>>s>>t;BF A(s,t);cout<<"主串S:"<<s<<'\n'<<"模式T:"<<t<<endl;cout<<A.bf()<<endl;return 0;}四、调试与运行1、调试时遇到的主要问题及解决答:基本没有大的错误,大多是一些细节问题,就是字符串的上传问题,我最后直接用指针搞定。
2、运行结果(输入及输出,可以截取运行窗体的界面)输入:abcdefgh defg;输出:五、实验心得答:通过本次的实验,让我加深了理解了串的操作。
实验一串匹配问题1.实验题目:给定一个文本S=“s1,s2,……sn”,在该文本中查找和定位任意给定的字符串T=“t1,t2,……tm”,T称为模式。
2.实验要求:实现BF算法和改进的算法KMP算法,编写实验程序,给出测试数据和测试结果。
并验证两种方法时间效率的差异。
3.实验目的:1)深刻理解蛮力法的设计思想。
2)提高应用蛮力法设计算法的技能。
3)理解这样一个观点,蛮力法经过适当改进,可以改进算法的时间性能。
4.实验源代码:1)BF算法代码如下:// tt.cpp: 主项目文件。
#include"stdafx.h"using namespace System;int bfstring(char s[],int n,char t[],int m){int i,j,k;for(i=1;i<=n-m+1;i++){j=1;k=i;while (s[k]==t[j]) {k++;j++;}if (j>m) return i;}return 0;}int main(array<System::String ^> ^args){char s[5],t[2];int n,m,i;Console::WriteLine(L"前5个为主串,后2个为匹配串");n=5;m=2;for (i=1;i<=n;i++){s[i]=Console::Read();}for (i=1;i<=m;i++){t[i]=Console::Read();}Console::WriteLine("从第"+bfstring(s,n,t,m)+"个位置开始匹配");; Console::Read();}2)KMPl算法代码如下:// y.cpp: 主项目文件。
#include"stdafx.h"using namespace System;int kmpstring(char s[],int n,char t[],int m){int i,j,k,next[5];next[1]=0;next[2]=1;j=2;k=1;while(j<m){if(k==0||t[j]==t[k]){j=j+1;k=k+1;next[j]=k;}else k=next[k];}j=2;for(i=1;i<=n;i++){j=next[j];if (j==0){i++;j++;}while(s[i]==t[j]){i++;j++;}if(j>m) return i-m;i=i-1;}return 0;}int main(array<System::String ^> ^args){char s[10],t[5];int n,m,i;Console::WriteLine(L"前10个为主串,后5个为匹配串");n=10;m=5;for (i=1;i<=n;i++){s[i]=Console::Read();}for (i=1;i<=m;i++){t[i]=Console::Read();}if (kmpstring(s,n,t,m)==0)Console::WriteLine("匹配失败");elseConsole::WriteLine("从第"+kmpstring(s,n,t,m)+"个位置开始匹配成功");Console::Read();}5.实验结果:1)BF算法运行结果:2)KMP算法运行结果;。
中北大学软件学院实验报告专业:_________________________方向:_________________________?课程名称:_________________________班级:_________________________学号:_________________________姓名:_________________________辅导教师:_________________________2016年3月制#成绩:成绩:?成绩:成绩:成绩:实验时间2016年4月8日8时至10时学时数21.实验名称实验五汉诺塔问题的程序设计2.实验目的(1) 掌握递归的有关概念(2) 掌握汉诺塔问题的具体求解过程》(3) 在掌握的基础上编程实现汉诺塔的具体实现过程3.实验内容在A上有按大小排序好的n个金碟,借助B的帮助,将A上的碟子移动到C上,在移动的过程中要严格按照大小顺序,不能将碟子放在比它小的上面,输出结果,输出时要求有文字说明。
请编写程序。
4.实验原理或流程图汉诺塔问题可以通过以下三个步骤实现:(1)将塔A上的n-1个碟子借助塔C先移到塔B上。
(2)把塔A上剩下的一个碟子移到塔C上。
(3)将n-1个碟子从塔B借助塔A移到塔C上。
显然,这是一个递归求解的过程。
【下方示意图画不下可省略】成绩:成绩:成绩:成绩:@成绩:成绩:实验一 BF算法运行结果截图$~实验二选择排序、起泡排序运行结果截图[实验三数字旋转方阵运行结果截图)—实验四归并排序、快速排序运行结果截图实验五汉诺塔问题运行结果截图:实验六折半查找和二叉查找树运行结果截图》实验七堆排序运行结果截图实验八淘汰赛冠军问题运行结果截图实验九数塔问题运行结果截图实验十多源点最短路径——Floyd算法运行结果截图实验十一贪心法解决TSP问题。
一、实验目的本次实验旨在让学生熟悉并掌握模式匹配的基本概念、算法及其应用。
通过实验,学生能够了解模式匹配算法的原理,掌握几种常见的模式匹配算法(如KMP算法、BF算法等)的实现方法,并能够运用这些算法解决实际问题。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 模式匹配基本概念- 模式匹配:在给定的文本中查找一个特定模式的过程。
- 模式:要查找的字符串。
- 文本:包含可能包含模式的字符串。
2. KMP算法- KMP算法(Knuth-Morris-Pratt)是一种高效的字符串匹配算法,其核心思想是避免重复比较已经确定不匹配的字符。
- 实现步骤:1. 构造一个部分匹配表(next数组)。
2. 遍历文本和模式,比较字符,并使用next数组调整模式的位置。
3. BF算法- BF算法(Boyer-Moore)是一种高效的字符串匹配算法,其核心思想是利用坏字符规则和好后缀规则来减少不必要的比较。
- 实现步骤:1. 计算坏字符规则。
2. 计算好后缀规则。
3. 遍历文本和模式,比较字符,并使用坏字符规则和好后缀规则调整模式的位置。
4. 模式匹配算法比较- 比较KMP算法和BF算法的时间复杂度、空间复杂度及适用场景。
四、实验步骤1. 初始化- 定义文本和模式字符串。
- 初始化模式匹配算法的参数。
2. 构造next数组(KMP算法)- 根据模式字符串构造部分匹配表(next数组)。
3. 计算坏字符规则和好后缀规则(BF算法)- 根据模式字符串计算坏字符规则和好后缀规则。
4. 遍历文本和模式- 使用KMP算法或BF算法遍历文本和模式,比较字符,并调整模式的位置。
5. 输出结果- 输出匹配结果,包括匹配的位置和匹配次数。
五、实验结果与分析1. KMP算法- 时间复杂度:O(nm),其中n为文本长度,m为模式长度。
- 空间复杂度:O(m)。
实验三串的模式匹配一、实验目的1.利用顺序结构存储串,并实现串的匹配算法。
2.掌握简单模式匹配思想,熟悉KMP算法。
二、实验要求1.认真理解简单模式匹配思想,高效实现简单模式匹配;2.结合参考程序调试KMP算法,努力算法思想;3.保存程序的运行结果,并结合程序进行分析。
三、实验内容1、通过键盘初始化目标串和模式串,通过简单模式匹配算法实现串的模式匹配,匹配成功后要求输出模式串在目标串中的位置;2、参考程序给出了两种不同形式的next数组的计算方法,请完善程序从键盘初始化一目标串并设计匹配算法完整调试KMP算法,并与简单模式匹配算法进行比较。
四、程序流程图、算法及运行结果3-1#include <stdio.h>#include <string.h>#define MAXSIZE 100int StrIndex_BF(char s[MAXSIZE],char t[MAXSIZE]){int i=1,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]);elsereturn -1;}int main(){char s[MAXSIZE];char t[MAXSIZE];int answer, i;printf("S String -->\n ");gets(s);printf("T String -->\n ");gets(t);printf("%d",StrIndex_BF(s,t)); /*验证*/if((answer=StrIndex_BF(s,t))>=0){printf("\n");printf("%s\n", s);for (i = 0; i < answer; i++)printf(" ");printf("%s", t);printf("\n\nPattern Found at location:%d\n", answer); }elseprintf("\nPattern NOT FOUND.\n");getch();return 0;}3-2#include <stdio.h>#include <string.h>#define MAXSIZE 100void get_nextval(unsigned char pat[],int nextval[]){int length = strlen(pat);int i=1;int j=0;nextval[1]=0;while(i<length){if(j==0||pat[i-1]==pat[j-1]){++i;++j;if(pat[i-1]!=pat[j-1]) nextval[i]=j;else nextval[i]=nextval[j];}else j=nextval[j];}}int Index_KMP(unsigned char text[], unsigned char pat[],int nextval[]) {int i=1;int j=1;int t_len = strlen(text);int p_len = strlen(pat);while(i<=t_len&&j<=p_len){if(j==0||text[i-1]==pat[j-1]){++i;++j;}else j=nextval[j];}if(j>p_len) return i-1-p_len;else return -1;}int main(){unsigned char text[MAXSIZE];unsigned char pat[MAXSIZE];int nextval[MAXSIZE];int answer, i;printf("\nBoyer-Moore String Searching Program"); printf("\n====================================");printf("\n\nText String --> ");gets(text);printf( "\nPattern String --> ");gets(pat);get_nextval(pat,nextval);if((answer=Index_KMP(text, pat,nextval))>=0){printf("\n");printf("%s\n", text);for (i = 0; i < answer; i++)printf(" ");printf("%s", pat);printf("\n\nPattern Found at location %d\n", answer); }elseprintf("\nPattern NOT FOUND.\n");getch();return 0;}3-3#include "stdio.h"void GetNext1(char *t,int next[]){int i=1,j=0;next[1]=0;while(i<=9){if(j==0||t[i]==t[j]){++i; ++j; next[i]=j; }elsej=next[j];}}void GetNext2(char *t , int next[]){int i=1, j = 0;next[1]= 0;while (i<=9){while (j>=1 && t[i] != t[j] )j = next[j];i++; j++;if(t[i]==t[j]) next[i] = next[j];else next[i] = j; }}void main(){char *p="abcaababc";int i,str[10];GetNext1(p,str);printf("Put out:\n");for(i=1;i<10;i++)printf("%d",str[i]);GetNext2(p,str);printf("\n");for(i=1;i<10;i++)printf("%d",str[i]);printf("\n");getch();}.。
实验一串的模式匹配1.程序设计简介为简化设计,程序直接利用C++字符数组作为串的存储结构。
程序提供显示串(包含主串和模式串)、计算Next[]、BF匹配、KMP匹配、重建主串、重建模式串等功能。
2. 源代码//串模式匹配的类定义FindSub.cpp#include<iomanip.h>#include<string.h>#include<stdio.h>#include<stdlib.h>#include<string>const maxsize=30;int IndexBF(char s[],char t[],int pos){int i,j,m,n;i=pos-1;j=0;m=strlen(s);n=strlen(t);while(i<m && j<n){if(s[i]==t[j]){++i;++j;}else {i=i-j+1;j=0;}}if(j>=n)return i-n+1;elsereturn -1;}void GetNext(char t[],int next[]){// 求模式串T的next函数值并存入数组nextint j=0,k=-1;int n=strlen(t);next[j]=-1;while(j<n){if(k==-1||t[j]==t[k]){j++;k++;next[j]=k;}else k=next[k];}}int IndexKMP(char s[],char t[],int next[],int pos){// 利用模式串T的next函数求T在主串S中第pos个字符之后的位置的KMP算法。
// 其中,T非空,1≤pos≤StrLength(S)int i,j,n;i=pos-1;j=0;int m=strlen(s);//s[m]='\0';n=strlen(t);//t[n]='\0';while(i<m && j<n)if(j==-1||s[i]==t[j]){i++;j++;}// 继续比较后继字符else j=next[j];// 模式串向右移动if(j>=n) return i-n+1;// 匹配成功return -1;}//串模式匹配的测试void main(){ char s[maxsize]="aaabaaaabaa",t[maxsize]="aaaab";int index,*next;int choice,j,pos=0;int m,n;m=strlen(s);n=strlen(t);next=new int[n];GetNext(t,next);do{//显示主菜单cout<<"1-BF匹配\n";cout<<"2-KMP匹配\n";cout<<"3-查看Next[]\n";cout<<"4-显示串\n";cout<<"6-退出\n";cout<<"Enter choice:";cin>>choice;switch(choice){case 1://BF匹配cout<<"输入匹配起始位置:";cin>>pos;if(pos<=m-n+1){cout<<"主串为:"<<s<<'\t'<<"子串为:"<<t<<endl;cout<<"BF的结果:"<<endl;index=IndexBF(s,t,pos);if(index!=-1)cout<<"模式串t在主串s中的位置从第"<<index<<"个字符开始"<<endl;else cout<<"主串s中不含模式串t"<<endl;}else{ cout<<"位置非法,无法匹配!"<<endl; }break;case 2://KMP算法cout<<"输入匹配起始位置:";cin>>pos;if(pos<=m-n+1){cout<<"主串为:"<<s<<'\t'<<"子串为:"<<t<<endl;cout<<"KMP匹配结果:"<<endl;index=IndexKMP(s,t,next,pos);if(index!=-1)cout<<"模式串在主串的位置从第"<<index<<"个字符开始"<<endl;elsecout<<"主串s中不含模式串t"<<endl;}else{ cout<<"位置非法,无法匹配!"<<endl; }break;case 3://显示NEXTcout<<"子串为:"<<t<<endl;for(j=0;j<n;j++){cout<<"next["<<j<<"]="<<next[j]<<'\t';if((j+1)%5==0) cout<<endl;}cout<<endl;break;case 4: //显示串cout<<"主串为:"<<s;cout<<"子串为: "<<t;cout<<endl;break;case 6://退出cout<<"结束运行!"<<endl;break;default:cout<<"Invalid choice\n";break;}}while(choice!=6);}3.程序运行结果:实验二求串中最长重复子串1.问题描述设串S=”s1s2……sn”,T=”t1t2……tm”,如果T∈S,则称T为S的子串。
实验题目:字符串的模式匹配一、实验描述用BF算法实现字符串的模式匹配二、实验目的和任务从主串的第pos位置字符开始和模式子串字符比较,如果相等,则继续逐个比较后续字符;否则从主串的下一个字符起再重新和模式子串的字符比较。
直到找到匹配字符串或者是主串结尾。
三、概要设计BF(Brute Force)算法是普通的模式匹配算法,BF算法的思想就是将目标串S的第一个字符与模式串P的第一个字符进行匹配,若相等,则继续比较S的第二个字符和P的第二个字符;若不相等,则比较S的第二个字符和P的第一个字符,依次比较下去,直到得出最后的匹配结果。
四、运行与测试#include <stdio.h>#include <string.h>int BFMatch(char *s,char *p){int i,j;i =0;while(i < strlen(s)){j = 0;while(s[i] == p[j] &&j<strlen(p)){i++;j++;}if(strlen(p) == j){return i - strlen(p);}i = i - j + 1; // 指针i回溯}return -1;}int main(){char *szSource = "ababcababa";char *szSub = "ababa";int index =BFMatch(szSource, szSub);printf("目标串包含匹配串的起始位置:%d",index);}五、运行结果六、实验心得通过这次课程设计,让我了解了字符串的定位操作即字符串模式匹配的基本概念和算法,探讨了字符串模式匹配操作的最基本的BF匹配算法。
虽然看起来很简单的程序,做起来却遇到了不少问题,编程中出行了一些小错误,多次查改之后再进行修改,所以我觉得在以后的学习中,我会更加注重实践,注重多练,多积累。
常熟理工学院《数据结构与算法》实验指导与报告书_2017-2018_____学年第__1__ 学期专业:物联网工程实验名称:串与模式匹配实验地点: N6-210 指导教师:聂盼红计算机科学与工程学院2017实验四串与模式匹配【实验目的】1、掌握串的存储表示及基本操作;2、掌握串的两种模式匹配算法:BF和KMP。
3、了解串的应用。
【实验学时】2学时【实验预习】回答以下问题:1、串和子串的定义串:串是由零个或多个任意字符组成的有限序列。
子串:串中任意连续字符组成的子序称为该串的字串。
2、串的模式匹配串的模式匹配是数据结构中字符串的一种基本运算,给定一个子串,要求在某个字符串中找出与该子串相同的所有子串,这就是模式匹配。
假设P是给定的子串,T是待查找的字符串,要求从T中找出与P相同的所有子串,这个问题成为模式匹配问题。
P称为模式,T 称为目标。
如果T中存在一个或多个模式为P的子串,就给出该子串在T中的位置,称为匹配成功;否则匹配失败【实1验内容和要求】/1、按照要求完成程序exp4_1.c,实现串的相关操作。
调试并运行如下测试数据给出运行结果:•求“This is a boy”的串长;•比较”abc 3”和“abcde“; 表示空格•比较”english”和“student“;•比较”abc”和“abc“;•截取串”white”,起始2,长度2;•截取串”white”,起始1,长度7;•截取串”white”,起始6,长度2;•连接串”asddffgh”和”12344”;实验代码:#include<stdio.h>#include<string.h>#define MAXSIZE 100#define ERROR 0#define OK 1/*串的定长顺序存储表示*/typedef struct{char data[MAXSIZE];int length;} SqString;int strInit(SqString *s); /*初始化串*/int strCreate(SqString *s); /*生成一个串*/ int strLength(SqString *s); /*求串的长度*/ int strCompare(SqString *s1,SqString *s2); /*两个串的比较*/ int subString(SqString *sub,SqString *s,int pos,int len); /*求子串*/ int strConcat(SqString *t,SqString *s1,SqString *s2); /*两个串的连接*//*初始化串*/int strInit(SqString *s){s->length=0;s->data[0]='\0';return OK;}/*strInit*//*生成一个串*/int strCreate(SqString *s){printf("input string :");gets(s->data);s->length=strlen(s->data);return OK;}/*strCreate*//*(1)---求串的长度*/int strLength(SqString *s){return s->length;}/*strLength*//*(2)---两个串的比较,S1>S2返回>0,s1<s2返回<0,s1==s2返回0*/int strCompare(SqString *s1,SqString *s2){int i;for(i=0; i<s1->length && i<s2->length; i++)if(s1->data[i] != s2->data[i])return s1->data[i] - s2->data[i];return s1->length - s2->length;}/*strCompare*//*(3)---求子串,sub为返回的子串,pos为子串的起始位置,len为子串的长度*/ int subString(SqString *sub,SqString *s,int pos,int len){int i;if(pos<1 || pos>s->length || len<0 || len>s->length-pos+1)return ERROR;sub->length = 0;for(i=0; i<len; i++){sub->data[i] = s->data[i+pos-1];sub->length++;}sub->data[i] = '\0';return OK;}/*subString*//*(4)---两个串连接,s2连接在s1后,连接后的结果串放在t中*/int strConcat(SqString *t,SqString *s1,SqString *s2){int i=0, j=0;while(i<s1->length){t->data[i] = s1->data[i];i++;}while(j<s2->length)t->data[i++] = s2->data[j++];t->data[i] = '\0';t->length = s1->length + s2->length;return OK;}/*strConcat*/int main(){system("color 1f");int n,k,pos,len;SqString s,t,x;do{printf("\n ---String--- \n");printf(" 1. strLentgh\n");printf(" 2. strCompare\n");printf(" 3. subString\n");printf(" 4. strConcat\n");printf(" 0. EXIT\n");printf("\n ---String---\n");printf("\ninput choice:");scanf("%d",&n);getchar();switch(n){case 1:printf("\n***show strLength***\n");strCreate(&s);printf("strLength is %d\n",strLength(&s));break;case 2:printf("\n***show strCompare***\n");strCreate(&s);strCreate(&t);k=strCompare(&s, &t); /*(5)---调用串比较函数比较s,t*/ if(k==0)printf("two string equal!\n");else if(k<0)printf("first string<second string!\n");elseprintf("first string>second string!\n");break;case 3:printf("\n***show subString***\n");strCreate(&s);printf("input substring pos,len:");scanf("%d,%d",&pos,&len);if(subString(&t,&s,pos,len))printf("subString is %s\n",t.data);elseprintf("pos or len ERROR!\n");break;case 4:printf("\n***show subConcat***\n");strCreate(&s);strCreate(&t);if(strConcat(&x, &s, &t)) /*(6)---调用串连接函数连接s&t*/ printf("Concat string is %s",x.data);elseprintf("Concat ERROR!\n");break;case 0:exit(0);default:break;}}while(n);return 0;}2、按照要求完成程序exp4_2.c,实现BF&KMP串的模式匹配算法。
第1篇一、实验目的1. 理解编码匹配算法的基本原理和流程;2. 掌握常见编码匹配算法的实现方法;3. 分析不同编码匹配算法的性能特点;4. 通过实验验证编码匹配算法在实际应用中的有效性。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 库:NumPy、SciPy、Pandas三、实验内容本次实验主要涉及以下几种编码匹配算法:1. 暴力匹配算法2. Knuth-Morris-Pratt (KMP) 算法3. Boyer-Moore 算法(一)暴力匹配算法1. 算法原理:暴力匹配算法是一种最简单的字符串匹配算法,其基本思想是逐个字符比较主串和模式串,一旦发现不匹配,则从主串的下一个字符重新开始比较。
2. 实现方法:编写一个函数,遍历主串的每个字符,与模式串的第一个字符比较,若匹配,则继续比较后续字符;若不匹配,则回退到主串的下一个字符重新开始比较。
3. 性能分析:暴力匹配算法的时间复杂度为O(nm),其中n为主串长度,m为模式串长度。
当模式串长度较长时,算法效率较低。
(二)Knuth-Morris-Pratt (KMP) 算法1. 算法原理:KMP算法通过预处理模式串,构建一个部分匹配表(也称为“失败函数”),以避免重复比较已知的字符。
2. 实现方法:首先,计算模式串的失败函数;然后,遍历主串,与模式串的第一个字符比较,若匹配,则继续比较后续字符;若不匹配,则利用失败函数回退到主串的下一个字符。
3. 性能分析:KMP算法的时间复杂度为O(n+m),其中n为主串长度,m为模式串长度。
相比暴力匹配算法,KMP算法在模式串长度较长时具有更高的效率。
(三)Boyer-Moore 算法1. 算法原理:Boyer-Moore算法通过构建一个坏字符表和一个好后缀表,预测不匹配的情况,从而避免不必要的比较。
2. 实现方法:首先,计算坏字符表和好后缀表;然后,遍历主串,与模式串的第一个字符比较,若匹配,则继续比较后续字符;若不匹配,则根据坏字符表和好后缀表进行回退。
东华理工大学长江学院信息工程系学生实验报告(1)专业:计算机科学与技术姓名:朱艳梅学号:2016030313251.实验目的(结合本次实验所涉及并要求掌握的知识点)1、了解串的基本概念2、掌握串的模式匹配算法的实现2.实验内容(结合实验内容具体描述)1. 补全代码,完成“串模式匹配4.1BF op 补全.cpp”3.算法描述及实验步骤(用适当的形式表达算法设计思想与算法实现步骤)/***字符串匹配算法***/#include<cstring>#include<iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSTRLEN 255 //用户可在255以内定义最长串长///把教材中的顺序存储结构的串的数据类型定义修改为:typedef char SString[MAXSTRLEN+1]; //0号单元存放串的长度Status StrAssign(SString T, char *chars) { //生成一个其值等于chars的串Tint i;if (strlen(chars) > MAXSTRLEN)return ERROR;else {T[0] = strlen(chars);for (i = 1; i <= T[0]; i++)T[i] = *(chars + i - 1);return OK;}}//算法4.1BF算法int Index(SString S, SString T, int pos){//返回模式T在主串S中第pos个字符之后第s一次出现的位置。
若不存在,则返回值为0//其中,T非空,1≤pos≤StrLength(S)int i = pos;int j = 1;while(i <= S[0]&&j <= T[0]){if(S[i]==T[j]) //继续比较后继字符,i和j的值分别+1{++i;++j;}else//指针后退重新开始匹配{i=i-j+2;j=1;}}if (j > T[0])return i - T[0];elsereturn 0;return 0;}//Index///从键盘输入主串,然后输入一个子串,打印子串在主串中首次匹配的位置int main(){SString S;char str[MAXSTRLEN+1];cout<<"输入主串S=";cin>>str;StrAssign(S,str) ;SString T;cout<<"输入模式子串T=";cin>>str;StrAssign(T,str) ;cout<<"主串和子串在第"<<Index(S,T,1)<<"个字符处首次匹配\n";return 0;}4.调试过程及运行结果(详细记录在调试过程中出现的问题及解决方法。
竭诚为您提供优质文档/双击可除串的模式匹配算法实验报告
篇一:串的模式匹配算法
串的匹配算法——bruteForce(bF)算法
匹配模式的定义
设有主串s和子串T,子串T的定位就是要在主串s中找到一个与子串T相等的子串。
通常把主串s称为目标串,把子串T称为模式串,因此定位也称作模式匹配。
模式匹配成功是指在目标串s中找到一个模式串T;不成功则指目标串s中不存在模式串T。
bF算法
brute-Force算法简称为bF算法,其基本思路是:从目标串s的第一个字符开始和模式串T中的第一个字符比较,若相等,则继续逐个比较后续的字符;否则从目标串s的第二个字符开始重新与模式串T的第一个字符进行比较。
以此类推,若从模式串T的第i个字符开始,每个字符依次和目标串s中的对应字符相等,则匹配成功,该算法返回i;否
则,匹配失败,算法返回0。
实现代码如下:
/*返回子串T在主串s中第pos个字符之后的位置。
若不存在,则函数返回值为0./*T非空。
intindex(strings,stringT,intpos)
{
inti=pos;//用于主串s中当前位置下标,若pos不为1则从pos位置开始匹配intj=1;//j用于子串T中当前位置下标值while(i j=1;
}
if(j>T[0])
returni-T[0];
else
return0;
}
}
bF算法的时间复杂度
若n为主串长度,m为子串长度则
最好的情况是:一配就中,只比较了m次。
最坏的情况是:主串前面n-m个位置都部分匹配到子串的最后一位,即这n-m位比较了m次,最后m位也各比较了一次,还要加上m,所以总次数为:(n-m)*m+m=(n-m+1)*m从
最好到最坏情况统计总的比较次数,然后取平均,得到一般情况是o(n+m).
篇二:数据结构实验报告-串
实验四串
【实验目的】
1、掌握串的存储表示及基本操作;
2、掌握串的两种模式匹配算法:bF和Kmp。
3、了解串的应用。
【实验学时】
2学时
【实验预习】
回答以下问题:
1、串和子串的定义
串的定义:串是由零个或多个任意字符组成的有限序列。
子串的定义:串中任意连续字符组成的子序列称为该串的子串。
2、串的模式匹配
串的模式匹配即子串定位是一种重要的串运算。
设s和t是给定的两个串,从主串s的第start个字符开始查找等
于子串t的过程称为模式匹配,如果在s中找到等于t的子串,则称匹配成功,函数返回t在s中首次出现的存储位置(或序号);否则,匹配失败,返回0。
【实验内容和要(:串的模式匹配算法实验报告)求】
1、按照要求完成程序exp4_1.c,实现串的相关操作。
调试并运行如下测试数据给出运行结果:
?求“Thisisaboy”的串长;
?比较”abc??3”和“abcde“;?表示空格
?比较”english”和“student“;
?比较”abc”和“abc“;
?截取串”white”,起始2,长度2;
?截取串”white”,起始1,长度7;
?截取串”white”,起始6,长度2;
?连接串”asddffgh”和”12344”;
#include
#include
#definemAxsIZe100
#defineeRRoR0
#defineoK1
/*串的定长顺序存储表示*/
typedefstruct
{
chardata[mAxsIZe];
intlength;
}sqstring;
intstrInit(sqstring*s);/*初始化串*/
intstrcreate(sqstring*s);/*生成一个串
*/intstrLength(sqstring*s);/*求串的长度
*/intstrcompare(sqstring*s1,sqstring*s2);/*两个串的比较
*/intsubstring(sqstring*sub,sqstring*s,intpos,intle n);/*求子串*/
intstrconcat(sqstring*t,sqstring*s1,sqstring*s2);/*两个串的连接*/
/*初始化串*/
intstrInit(sqstring*s)
{
s->length=0;
s->data[0]=\0;
returnoK;
}/*strInit*/
/*生成一个串*/
intstrcreate(sqstring*s)
{
printf("inputstring:");
gets(s->data);
s->length=strlen(s->data);
returnoK;
}/*strcreate*/
/*(1)---求串的长度*/
intstrLength(sqstring*s)
{
returns->length;
}/*strLength*/
/*(2)---两个串的比较,s1>s2返回>0,s1 intstrcompare(sqstring*s1,sqstring*s2) {
inti;
for(i=0;ilengthi++)
{
if(s1->data[i]>s2->data[i])
{
return1;
}
if(s1->data[i]data[i])
{
return-1;
}
}
return0;
}/*strcompare*/
/*(3)---求子串,sub为返回的子串,pos为子串的起始位置,len为子串的长度
*/intsubstring(sqstring*sub,sqstring*s,intpos,intle n)
{
inti;
if(poss->length||lens->length-pos+1)
{
returneRRoR;
}
sub->length=0;
for(i=0;i {
sub->data[i]=s->data[i+pos-1];
sub->length++;
}
sub->data[i]=\0;
returnoK;
}/*substring*/
/*(4)---两个串连接,s2连接在s1后,连接后的结
果串放在t中*/
intstrconcat(sqstring*t,sqstring*s1,sqstring*s2) {
inti=0,j=0;
while(ilength)
{
t->data[i]=s1->data[i];
i++;
}
while(jlength)
{
t->data[i++]=s2->data[j++];
}
t->data[i]=\0;
t->length=s1->length+s2->length;
returnoK;
}/*strconcat*/
intmain()
{
intn,k,pos,len;
sqstrings,t,x;
do
{
printf("\n---string---\n");
printf("1.strLentgh\n");
printf("2.strcompare\n");
printf("3.substring\n");
printf("4.strconcat\n");
printf("0.exIT\n");
printf("\n---string---\n");
printf("\ninputchoice:");
scanf("%d",
getchar();
switch(n)
{
case1:
printf("\n***showstrLength***\n"); strcreate(
printf("strLengthis%d\n",strLength( break;
case2:
printf("\n***showstrcompare***\n"); strcreate(
strcreate(。