串匹配实验报告
串的模式匹配问题实验总结(用C实现)

串的模式匹配问题实验总结(用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)、熟悉C语言的上机环境,进一步掌握C语言的结构特点;(2)、掌握串的定义及C语言实现;(3)、掌握串的模式匹配及C语言实现;(4)、掌握串的各种基本操作;实验步骤:(1)、建立链串类型(2)、实现匹配过程中需考虑的链表的特征。
实验内容:4.一个字符串中的任意一个子序列,若子序列中各字符值均相同,则成为字符平台。
写一算法,输入任意以字符串S,输出S中长度最大的所有字符平台的起始位置及所含字符。
注意,最大字符平台有可能不止一个。
实验数据记录:(源代码及执行过程)#include<stdio.h>#include<stdlib.h>#define Maxsize 20#define n 100typedef struct Node{int element[Maxsize];int front;int rear;}Queue;int EnterQueue(Queue *Q,int x){if((Q->rear+1)%Maxsize == Q->front){printf("队列已满!\n");return 0;}Q->element[Q->rear] = x;Q->rear = (Q->rear+1)%Maxsize;return 1;}int DeleQueue(Queue *Q,int *x){if(Q->front == Q->rear){printf("队列为空!\n");return 0;}*x = Q->element[Q->front];Q->front = (Q->front+1)%Maxsize;return 1;}int Donull(Queue *Q){while(Q->front != Q->rear){Q->element[Q->front] = 0;Q->front = (Q->front+1)%Maxsize;}Q->front = Q->rear = 0;if(Q->front == Q->rear){return 1;}else{return 0;}}int main(void){char str[n];int i=0,j=1,k=1,ch,p=1,flag=1;Queue *Q;Q = (Queue *)malloc(sizeof(Queue));Q->front = Q->rear = 0;printf("请输入字符串:");gets(str);while('\0' != *(str+i)){ while(*(str+i+1) == *(str+i)){if(flag){p = i;flag = 0;}i++;j++;}if(flag){p = i;}if(j >= k){if(j > k){Donull(Q);k = j;}if(EnterQueue(Q ,j) == 0)break;if(EnterQueue(Q,p+1) == 0)break;if(EnterQueue(Q,*(str+i)) == 0)break;}j=1;i++;flag = 1;} while(Q->front < Q->rear){DeleQueue(Q,&j);DeleQueue(Q,&k);DeleQueue(Q,&ch);printf("%-10d",k);for(i = 0; i < j; i++){printf("%c",ch);}printf("\n");}printf("\n");system("pause");}。
实验三串的模式匹配

实验三串的模式匹配⼀、实验⽬的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、实现串的模式匹配算法。
串匹配算法实验报告

一、实验目的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)进一步熟悉在PC机上建立、汇编、连接、调试和运行汇编语言程序的过程。
二、实验要求根据提示信息,从键盘输入两个字符串,实现两个字符串的比较。
如两个字符串中有一个字符相同,则显示“MATCH”,否则显示“NO MA TCH”.三、实验程序框图本实验程序如图所示:Array四、参考程序CRLF MACROMOV AH ,02HMOV DL,0DHINT 21HMOV AH,02HMOV DL,0AHINT 21HENDMDATA SEGMENTMESS1 DB’MATCH’,0DH,0AH,’$’MESS2 DB’NO MA TCH’,0DH,0AH,’MAXLEN1 DB 81ACTLEN1 DB ?STRING1 DB 81 DUP(?)MAXLEN2 DB 81ACTLEN2 DB?STRING2 DB 81 DUP(?)DATA ENDSSTACK SEGMENT STACKSTA DB 50 DUP(?)TOP EQU LENGTH STASTACK ENDSCODE SEGMENTASSUME CS: CODE,DS:DA TA,ES:DATA,SS:STACK START: MOV AX,DA TAMOV DS,AXMOV ES,AXMOV AX,STACKMOV SS,AXMOV SP,TOPMOV AH,09HMOV DX,OFFSET MESS3INT 21HCRLFMOV AH,0AHMOV DX,OFFSET MAXLEN1INT 21HCRLFMOV AH,09HMOV DX,OFFSET MESS4INT 21HMOV AX,0AHMOV DX,OFFSET MAXLEN2INT 21HCRLFCLDMOV SI,OFFSET STRING1MOV CL,[SI-1]MOV CH,00HKKK: MOV DI,OFFSET STRING2 PUSH CXMOV CL,[DI-1]MOV CH,00HMOV AL,[SI]MOV DX,DIREPNZ SCASBJZ GGGINC SIPOP CXLOOP KKKMOV AH,09HMOV DX,OFFSET MESS2INT 21HJMP PPPGGG: MOV AH,09HMOV DX,OFFSET MESS1INT 21HPPP: MOV AX,4C00HINT 21HCODE ENDSEND START。
3.7 实验项目——串匹配问题

1. 实验题目
给定一个文本,在该文本中查找并定位任意给定字符串。
2.实验目的 ⑴ 深刻理解并掌握脫力法的设计思想; ⑵ 提高应用脫力法设计算法的技能; ⑶ 理解这样一个观点:用脫力法设计的算法,一般来说,经过适度的努力 后,都可以对算法的第一个版本进行一定程度的改良,改进其时间性能。
S="a b a b c a b c a c b a b" T="a b c a c"
k j (2)则Tj-(k-1) ~ Tj-1 =Si-(k-1) ~ Si-1
两式联立可得:T1~Tk-1=Tj-(k-1) ~Tj-1
T1…Tk-1=Tj-(k-1) …Tj-1说明了什么? (1) k 与 j 具有函数关系,由当前失配位置 j , 可以计算出滑动位置 k(即比较的新起点); (2)滑动位置k 仅与模式串T有关。 T1…Tk-1=Tj-(k-1) …Tj-1的物理意义是什么?
在扫描过程中两两比较相邻记录,如果反序则交换,最终,最大记录就被“沉 到”了序列的最后一个位置,第二遍扫描将第二大记录“沉到”了倒数第二个 位置,重复上述操作,直到n-1 遍扫描后,整个序列就排好序了。
反序则交换
rj
rj+1 ri+1 ≤ …… ≤ rn-1 ≤rn
有序区 位于最终位置
无序区 1≤j≤i-1
从第1位往右 经过Байду номын сангаас-1位
从j-1位往左 经过k-1位
模式应该向右滑多远才是最高效率的?
k=max { k |1<k<j 且T1…Tk-1=Tj-(k-1) …Tj-1 }
令k = next[ j ],则:
0 当j=1时 //不比较 next[ j ]= max { k | 1<k<j 且T1…Tk-1=Tj-(k-1) …Tj-1 } 1 其他情况
串的数据结构实验报告

串的数据结构实验报告串的数据结构实验报告一、引言在计算机科学中,串(String)是一种基本的数据结构,用于存储和操作字符序列。
串的数据结构在实际应用中具有广泛的用途,例如文本处理、搜索引擎、数据库等。
本实验旨在通过实践掌握串的基本操作和应用。
二、实验目的1. 理解串的概念和基本操作;2. 掌握串的存储结构和实现方式;3. 熟悉串的常见应用场景。
三、实验内容1. 串的定义和基本操作在本实验中,我们采用顺序存储结构来表示串。
顺序存储结构通过一个字符数组来存储串的字符序列,并使用一个整型变量来记录串的长度。
基本操作包括:- 初始化串- 求串的长度- 求子串- 串的连接- 串的比较2. 串的模式匹配串的模式匹配是串的一个重要应用场景。
在实验中,我们将实现朴素的模式匹配算法和KMP算法,并比较它们的性能差异。
四、实验步骤1. 串的定义和基本操作首先,我们定义一个结构体来表示串,并实现初始化串、求串的长度、求子串、串的连接和串的比较等基本操作。
2. 串的模式匹配a. 实现朴素的模式匹配算法朴素的模式匹配算法是一种简单但效率较低的算法。
它通过逐个比较主串和模式串的字符来确定是否匹配。
b. 实现KMP算法KMP算法是一种高效的模式匹配算法。
它通过利用已匹配字符的信息,避免不必要的比较,从而提高匹配效率。
3. 性能比较与分析对比朴素的模式匹配算法和KMP算法的性能差异,分析其时间复杂度和空间复杂度,并讨论适用场景。
五、实验结果与讨论1. 串的基本操作经过测试,我们成功实现了初始化串、求串的长度、求子串、串的连接和串的比较等基本操作,并验证了它们的正确性和效率。
2. 串的模式匹配我们对两种模式匹配算法进行了性能测试,并记录了它们的运行时间和内存占用情况。
结果表明,KMP算法相较于朴素算法,在大规模文本匹配任务中具有明显的优势。
六、实验总结通过本实验,我们深入学习了串的数据结构和基本操作,并掌握了串的模式匹配算法。
“串匹配问题“实验报告

实验一串匹配问题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算法运行结果;。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验成绩
华中师范大学计算机科学系
实验报告书
实验项目:串匹配问题
课程名称:算法分析与设计
班级: 1
实验时间:周六早上8:30-11:30
实验目的:一、深刻理解并掌握蛮力法的设计思想。
二、提高应用蛮力法设计算法的技能。
三、理解这样一个观点:用蛮力法设计的算法,一般来说,经过适
当的努力之后,都可以对算法的第一个版本进行一定程度的改
良,改进其时间性能。
实验报告要求:1、实现BF算法。
2、实现BF的改进算法:KMP算法。
3、对上述算法进行时间复杂性分析,并设计实验程序,分析结果。
BF算法内容:
#include<iostream>
#include<string.h>
using namespace std;
#define M 80
#define N 50
void main()
{
char S[M],T[N];
int i,j,count=0;
cout<<"请输入长串S:";
gets(S);
cout<<"请输入子串T:";
gets(T);
i=0;j=0;
while(count!=strlen(T)&&i<(strlen(S)))
{
int k=i;
if(S[i]==T[j])
{i++;j++,count++;}
else
{i=k+1;j=0;count=0;}
}
if(count==strlen(T))
{
cout<<"子串从长串的第"<<i-strlen(T)+1<<"位开始匹配成
功!"<<endl;
// break;
}
if(count!=strlen(T))
cout<<"字符串匹配失败!"<<endl;
}
此算法的时间复杂度为O(M*N);
结果一:成功匹配
结果二:匹配失败
经改进后的KMP算法内容:
# include <iostream>
# include <string>
using namespace std;
#define M 80
#define N 50
void getnext(char *t,int *next)
{
int k = -1,j = 0;
next[0] = -1;
next[1] = 0;
while(j < strlen(t))
{
if((k == -1) || (t[j] == t[k])) {
j++;
k++;
next[j]=k;
}
else
{
k = next[k];
}
}
}
void main()
{
int i,j,count=0;
char S[M],T[N];
cout<<"请输入长串S:";
cin>>S;
cout<<"请输入子串T:";
cin>>T;
int n = strlen(T);
int *next = new int[n];
getnext(T,next);
for(i=0,j=0;i<strlen(S)&&j<strlen(T);)
{
if((j == 0)||(S[i] == T[j]))
{
i++;
j++;
}
else
{
j = next[j];
}
}
if(j==strlen(T))
cout<<"子串从长串的第"<<i-j+1<<"位开始匹配成功!"<<endl;
else
cout<<"字符串匹配失败!"<<endl;
} 此算法的时间复杂度为O(N);
若匹配成功,结果如下:
若字符串S和T不匹配,结果如下:
问题分析:通过两种算法的比较,主要区别在于next数组的加入,我通过上网查询以及参考书本上next数组的求解方法,得出此KMP算法,语法上无任何错误,经多次修改,得此算法。
注意next数组与j衔接以防出错。