实验三____串的模式匹配

合集下载

串的模式匹配算法

串串（String）又叫做字符串，是一种特殊的线性表的结构，表中每一个元素仅由一个字符组成。

随着计算机的发展，串在文字编辑、词法扫描、符号处理以及定理证明等诸多领域已经得到了越来越广泛的应用。

第一节串的定义和表示1、串的逻辑结构定义串是由零个到任意多个字符组成的一个字符序列。

一般记为：S=’ a1a2a3……a n’(n>=0)其中S为串名，序列a1a2a3……a n为串值，n称为串的长度，我们将n=0的串称为空串(null string)。

串中任意一段连续的字符组成的子序列我们称之为该串的子串，字符在序列中的序号称为该字符在串中的位置。

在描述中，为了区分空串和空格串(s=‘’)，我们一般采用来表示空串。

2、串的基本操作串一般包含以下几种基本的常用操作：1、length(S)，求S串的长度。

2、delete(S,I,L)，将S串从第I位开始删除L位。

3、insert(S,I,T)，在S的第I位之前插入串T。

4、str(N,S)，将数字N转化为串S。

5、val(S,N,K)，将串S转化为数字N；K的作用是当S中含有不为数字的字符时，K记录下其位置，并且S没有被转化为N。

3、串的储存结构一般我们采用以下两种方式保存一个串：1、字符串类型，描述为：const n=串的最大长度type strtype=string[n]这里由于tp的限制，n只能为[1..255]。

在fp或者delphi中，我们还可以使用另外一种类型，描述为：const n=串的最大长度type strtype=qstring[n]这里的n就没有限制了，只要空间允许，开多大都可以。

2、数组来保存，描述为：const n=串的最大长度type strtype=records:array[1..n] of char;len:0..n;end;第二节模式匹配问题与一般的线性表不同，我们一般将串看成一个整体，它有一种特殊的操作——模式匹配。

串的模式匹配算法实验报告

竭诚为您提供优质文档/双击可除串的模式匹配算法实验报告篇一：串的模式匹配算法串的匹配算法——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、串和子串的定义串的定义：串是由零个或多个任意字符组成的有限序列。

串的模式匹配

实验四顺序串的各种模式匹配一、实验目的熟悉串的有关概念，掌握串的存储结构及串的模式匹配算法。

二、实验内容由用户随意输入两个串：主串S和模式串T，设S=‘s1s2…sn’，T=‘t1t2…tm’，且0<m<=n。

1（必做）、用简单模式匹配算法判断模式串T是否在主串S中，若在，则输出模式串在主串的第一匹配位置，否则，匹配失败，返回零值。

2（选做）、用KMP模式匹配算法判断模式串T是否在主串S中，若在，则输出模式串在主串的第一匹配位置，否则，匹配失败，返回零值。

三、算法思想与算法描述单链表是线性表的链式存储结构的一种形式，它用一组地址任意的存储单元存放线性表的各个元素。

四、实验步骤与算法实现#include<iostream>#include<malloc.h>using namespace std;typedef struct taglin{int data;taglin* next;}lin;void initlin(lin* &L,int e){lin* p=L,* s;while(p->next!=NULL)p=p->next;s=(lin*)malloc(sizeof(lin));s->data=e;s->next=p->next;p->next=s;}void main(){int num,e,x,y,count=-1,c=0,e1,t=-2147483648;bool mark=false;lin* L,* tx,* p,* q;L=(lin*)malloc(sizeof(lin));L->next=NULL;cout<<"输入个数>=2"<<endl;cin>>num;if(num<2){cout<<"输入比2小的值_错误"<<endl;getchar();getchar();}cout<<"输入"<<num<<"个非递减整形数字"<<endl;for(int i=0;i<num;i++){cin>>e;initlin(L,e);if(c==0){e1=e;c++;}if(e<t){cout<<"输入的值比前一个值小_错误"<<endl;getchar();getchar();}t=e;}cout<<"输入x y"<<endl;cin>>x>>y;if(y>=e)mark=true;if(e1>x)x=e1;tx=L->next;for(;tx->data<=x;tx=tx->next);p=L->next;for(;p!=NULL&&p->next!=tx;p=p->next);q=p;if(!mark){for(;p!=NULL&&p->data<=y;p=p->next)count++;p=q;q=q->next;for(;count>0;count--){p->next=q->next;q=q->next;}for(p=L,q=p->next;p->next!=NULL;p=p->next){if(p->next->data==x)p->next=q->next;q=q->next;}}else{if(e1<x){p=L;for(;p->next!=tx&&p->next!=NULL;p=p->next);p->next=NULL;}elseL->next=NULL;}cout<<"_____________"<<endl;for(p=L->next;p!=NULL;p=p->next)cout<<p->data<<" "<<endl;getchar();getchar();}五、实验测试及结果六、总结与体会理解了模式匹配基本方法，但kmp比较复杂，任然需要时间去学习。

北邮数据结构实验报告

北邮数据结构实验报告摘要：本报告基于北邮数据结构实验，通过实际操作和实验结果的分析，总结和讨论了各实验的目的、实验过程、实验结果以及相关的问题和解决方法。

本报告旨在帮助读者了解数据结构实验的基本原理和应用，并为今后的学习和研究提供参考。

1. 实验一：线性表的操作1.1 实验目的本实验旨在掌握线性表的基本操作以及对应的算法实现，包括插入、删除、查找、修改等。

1.2 实验过程我们使用C++语言编写了线性表的相关算法，并在实际编程环境下进行了测试。

通过插入元素、删除元素、查找元素和修改元素的操作，验证了算法的正确性和效率。

1.3 实验结果经过测试，我们发现线性表的插入和删除操作的时间复杂度为O(n)，查找操作的时间复杂度为O(n)，修改操作的时间复杂度为O(1)。

这些结果与预期相符，并反映了线性表的基本特性。

1.4 问题与解决方法在实验过程中，我们遇到了一些问题，例如插入操作的边界条件判断、删除操作时的内存释放等。

通过仔细分析问题，我们优化了算法的实现，并解决了这些问题。

2. 实验二：栈和队列的应用2.1 实验目的本实验旨在掌握栈和队列的基本原理、操作和应用，并进行实际编程实现。

2.2 实验过程我们使用C++语言编写了栈和队列的相关算法，并在实际编程环境下进行了测试。

通过栈的应用实现表达式求值和逆波兰表达式的计算，以及队列的应用实现图的广度优先遍历，验证了算法的正确性和效率。

2.3 实验结果经过测试，我们发现栈的应用可以实现表达式的求值和逆波兰表达式的计算，队列的应用可以实现图的广度优先遍历。

这些结果证明了栈和队列在实际应用中的重要性和有效性。

2.4 问题与解决方法在实验过程中，我们遇到了一些问题，例如中缀表达式转后缀表达式的算法设计、表达式求值的优化等。

通过查阅资料和与同学的讨论，我们解决了这些问题，并完善了算法的实现。

3. 实验三：串的模式匹配3.1 实验目的本实验旨在掌握串的基本操作和模式匹配算法，并进行实际编程实现。

数据结构实验总结及心得体会

数据结构实验总结及心得体会引言数据结构作为计算机科学的基础课程，是理解和应用计算机编程的重要部分。

通过实验的形式，我们可以更加深入地理解不同数据结构的特点和应用场景。

本文将总结我在数据结构实验中的学习经验和心得体会。

实验一：线性表在线性表实验中，我学习了顺序表和链表两种基本的线性表结构。

顺序表使用数组来存储数据，具有随机访问的特点；链表使用指针来连接数据元素，具有插入和删除操作方便的特点。

通过这个实验，我深刻认识了线性表的存储结构和操作方法。

我遇到的难点是链表的插入和删除操作，因为涉及到指针的重新指向。

通过调试和分析代码，我逐渐理解了指针指向的含义和变化规律。

在实验结束后，我还进一步学习了循环链表和双向链表的特点和应用。

实验二：栈和队列栈和队列是两种常用的数据结构，可以用来解决很多实际问题。

在这个实验中，我学习了顺序栈、链式栈、顺序队列和链式队列四种基本实现方式。

实验中我遇到的最大困难是队列的循环队列实现，因为需要处理队列尾指针的位置变化。

我通过画图和调试发现了队列尾指针的变化规律，并在实验中成功实现了循环队列。

熟练掌握了栈和队列的操作方法后，我进一步学习了栈的应用场景，如表达式求值和括号匹配等。

队列的应用场景还有优先级队列和循环队列等。

实验三：串串是由零个或多个字符组成的有限序列，是实际应用中十分常见的数据类型。

在这个实验中，我学习了串的存储结构和常规操作。

实验中最具挑战性的部分是串的模式匹配。

模式匹配是在一个主串中查找一个子串的过程，可以使用暴力匹配、KMP 算法和BM算法等不同的匹配算法。

在实验中，我实现了KMP算法，并在实际应用中进行了测试。

从实验中我学到了使用前缀表和后缀表来提高模式匹配的效率。

同时，在应用中也了解到了串的搜索和替换等常见操作。

实验四：树和二叉树树是一种重要的非线性数据结构，应用广泛。

在这个实验中，我学习了树的基本概念、存储结构和遍历方式。

实验中最困难的部分是二叉树的遍历。

串匹配算法实验报告

一、实验目的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.算法一：暴力匹配法暴力匹配法是最简单直观的一种模式匹配算法，它通过逐个比较主串和模式串的字符进行匹配。

具体步骤如下：1.从主串的第一个字符开始，逐个比较主串和模式串的字符。

2.如果当前字符匹配成功，则比较下一个字符，直到模式串结束或出现不匹配的字符。

3.如果匹配成功，返回当前字符在主串中的位置，否则继续从主串的下一个位置开始匹配。

3.算法二：KMP匹配算法KMP匹配算法是一种改进的模式匹配算法，它通过构建一个部分匹配表来减少不必要的比较次数。

具体步骤如下：1.构建模式串的部分匹配表，即找出模式串中每个字符对应的最长公共前后缀长度。

2.从主串的第一个字符开始，逐个比较主串和模式串的字符。

3.如果当前字符匹配成功，则继续比较下一个字符。

4.如果当前字符不匹配，则根据部分匹配表的值调整模式串的位置，直到模式串移动到合适的位置。

4.算法三：Boyer-Moore匹配算法Boyer-Moore匹配算法是一种高效的模式匹配算法，它通过利用模式串中的字符出现位置和不匹配字符进行跳跃式的匹配。

具体步骤如下：1.构建一个坏字符规则表，记录模式串中每个字符出现的最后一个位置。

2.从主串的第一个字符开始，逐个比较主串和模式串的字符。

3.如果当前字符匹配成功，则继续比较下一个字符。

4.如果当前字符不匹配，则根据坏字符规则表的值调整模式串的位置，使模式串向后滑动。

5.算法四：Rabin-Karp匹配算法Rabin-Karp匹配算法是一种基于哈希算法的模式匹配算法，它通过计算主串和模式串的哈希值进行匹配。

具体步骤如下：1.计算模式串的哈希值。

2.从主串的第一个字符开始，逐个计算主串中与模式串长度相同的子串的哈希值。

第3章蛮力法——串的模式匹配

模式匹配——BF算法
例：主串S="ababcabcacbab"，模式T="abcac"
i
第 5 趟
a b a b c a b c a c b a b a b c a c
j
i=5，j=1失败 i回溯到6，j回溯到1
模式匹配——BF算法
例：主串S="ababcabcacbab"，模式T="abcac"
i i i i i
第 3 趟
a b a b c a b c a c b a b a b c a c
j j j j j
i=7，j=5失败 i回溯到4，j回溯到1
模式匹配——BF算法
例：主串S="ababcabcacbab"，模式T="abcac"
i
第 3 趟
a b a b c a b c a c b a b a b c a c
k
算法3.4——KMP算法中求next数组
void GetNext(char T[ ], int next[ ]) { 位置j 1 2 3 4 5 next[1]=0; j=1; k=0; 模式串 a b c a c while (j<T[0]) if ((k= =0)| |(T[j]= =T[k])) j next[j] { j++; 1 0 k++; 2 1 next[j]=k; 3 1 } 4 1 else k=next[k]; } 5 2
next数组的求解方法是： 1、第一位的next值为0，第二位的next值为1，
2、第三位开始首先将当前位的前一位字符与其next值对应的字符进行比较，相等:则该位的next值就是前一位的next值加上1；

串及其应用的实验报告

串及其应用的实验报告串及其应用的实验报告引言：串是计算机科学中一种基本的数据结构，它由一系列字符组成，可以是字母、数字或其他符号。

在计算机编程中，串常常用于存储和处理文本信息。

本实验旨在通过实践操作，探索串的基本特性和应用。

实验一：串的创建和操作1. 实验目的通过编写程序，学习串的创建和操作方法。

2. 实验步骤（1）使用编程语言创建一个空串。

（2）向串中添加字符，观察串的变化。

（3）使用串的长度函数，计算串的长度。

（4）使用串的比较函数，比较两个串的大小。

（5）使用串的连接函数，将两个串连接起来。

（6）使用串的截取函数，截取指定位置和长度的子串。

3. 实验结果通过实验步骤的操作，我们成功创建了一个空串，并向其中添加了字符。

使用长度函数计算出了串的长度，并使用比较函数比较了两个串的大小。

通过连接函数，我们将两个串连接成了一个新的串。

最后，使用截取函数，我们截取了指定位置和长度的子串。

实验二：串的模式匹配1. 实验目的通过实验操作，了解串的模式匹配算法。

2. 实验步骤（1）使用编程语言实现串的模式匹配算法。

（2）创建一个主串和一个模式串。

（3）使用模式匹配算法，在主串中查找模式串的位置。

3. 实验结果通过实验步骤的操作，我们成功实现了串的模式匹配算法。

创建了一个主串和一个模式串，并使用算法在主串中找到了模式串的位置。

实验三：串的应用——文本编辑器1. 实验目的通过实验操作，熟悉串的应用——文本编辑器。

2. 实验步骤（1）使用编程语言实现一个简单的文本编辑器。

（2）实现文本插入、删除和替换功能。

（3）实现文本搜索和替换功能。

3. 实验结果通过实验步骤的操作，我们成功实现了一个简单的文本编辑器。

可以插入、删除和替换文本，还可以进行文本搜索和替换。

结论：通过本次实验，我们对串及其应用有了更深入的了解。

串作为计算机科学中常用的数据结构，具有广泛的应用领域。

通过实践操作，我们掌握了串的创建和操作方法，并学会了串的模式匹配和文本编辑器的应用。

串的模式匹配

串的模式匹配（1）、Brute-Force 暴风(Brute Force)算法是普通的模式匹配算法，BF算法的思想就是将⽬标串S的第⼀个字符与模式串T的第⼀个字符进⾏匹配，若相等，则继续⽐较S的第⼆个字符和 T的第⼆个字符；若不相等，则⽐较S的第⼆个字符和T的第⼀个字符，依次⽐较下去，直到得出最后的匹配结果。

BF算法是⼀种蛮⼒算法。

如⽬标串："caatcat"，t="cat",pos=1，匹配过程如图程序如下：#include<stdio.h>#include<stdlib.h>#define MAXNUM 100//顺序串的存储结构，即串中的字符被依次存放在⼀组连续的存储单元中typedef struct St{char *ch; //存放串的起始地址，串中的第i个元素存储在ch[i-1]中int length; //串的长度int strsize;//分配给串的存储空间⼤⼩，若不够，通过realloc()再分配，增加存储空间}String;String CreateNullString(){String s;s.ch=(char *)malloc(MAXNUM*sizeof(char)); //初始化串的存储空间s.length=0;s.strsize=MAXNUM;return s;}//为字符串赋值void Stringassign(String *s,char s2[]){int i=0;//统计串s2的长度，若不够，然后再通过realloc去增加存储空间while(s2[i]!='\0')i++;if(i>s->strsize){s->ch=(char *)realloc(s->ch,i*sizeof(char));s->strsize=i;}s->length=i;for(i=0;i<s->length;i++)s->ch[i]=s2[i];}/*s:⽬标字符串t:匹配字符串pos:索引*/int index(String s,String t,int pos){int i,j;if(pos<1 || s.length<pos || s.length-t.length+1<pos){printf("输⼊参数不合理\n");exit(0);}i=pos-1;j=0;while(i<s.length && j<t.length){if(s.ch[i]==t.ch[j]){i++; //第i个字符相等，继续匹配j++;}else{i=i-j+1; //匹配失败，初始i的后⼀个位置继续开始匹配j=0;}}if(j>=t.length)return i-t.length+1; //匹配成功，返回第匹配成功的字符串的起始地址elsereturn 0; //未匹配成功}void main(){String s,t;int i;char ch[MAXNUM];s=CreateNullString();t=CreateNullString();printf("请输⼊主字符串：");gets(ch);Stringassign(&s,ch);printf("输⼊⼦串：");gets(ch);Stringassign(&t,ch);printf("输⼊匹配的起始地址：");scanf("%d",&i);i=index(s,t,i);printf("%d\n",i);}运⾏结果如下：备注：关于get()和scanf()函数的区别gets() : gets从标准输⼊设备读字符串函数。

实验三-串的模式匹配

实验三串的模式匹配一、实验目的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. 掌握字符串的基本概念和表示方法；2. 学习串的初始化、赋值和销毁操作；3. 熟悉串的基本操作，如求串的长度、比较串、连接串等；4. 掌握串的模式匹配算法。

实验过程：1. 字符串的初始化和赋值在本次实验中，我们使用C语言来进行串操作的实现。

首先，我们需要初始化一个字符串，并为其分配内存空间。

然后，我们可以通过赋值操作将一个字符串赋给另一个字符串。

这样，我们就可以对这个字符串进行各种操作。

2. 求串的长度求串的长度是串操作中的一个基本操作。

我们可以通过遍历字符串中的每一个字符，并计数来得到字符串的长度。

在实际操作中，我们可以使用strlen()函数来实现这个功能。

3. 比较串比较串是判断两个字符串是否相等的操作。

我们可以逐个字符地比较两个字符串中的字符，如果所有字符都相等，则认为两个字符串相等。

在实际操作中，我们可以使用strcmp()函数来实现这个功能。

4. 连接串连接串是将两个字符串连接成一个新的字符串的操作。

我们可以先计算出新字符串的长度，然后将两个字符串中的字符逐个复制到新的字符串中。

在实际操作中，我们可以使用strcat()函数来实现这个功能。

5. 串的模式匹配串的模式匹配是在一个字符串中查找另一个字符串的操作。

我们可以通过遍历字符串中的每一个字符，并与目标字符串进行比较来实现这个功能。

在实际操作中，我们可以使用strstr()函数来实现这个功能。

实验结果：通过实验，我们成功地完成了串操作的各项任务。

我们学会了如何初始化和赋值字符串，如何求串的长度，如何比较和连接串，以及如何进行串的模式匹配。

这些技术对于我们在日后的编程工作中处理字符串将会非常有帮助。

结论：串操作是计算机科学中的一项基本操作，它对于我们处理字符串非常重要。

字符串的模式匹配实验报告

实验题目：字符串的模式匹配一、实验描述用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匹配算法。

虽然看起来很简单的程序，做起来却遇到了不少问题，编程中出行了一些小错误，多次查改之后再进行修改，所以我觉得在以后的学习中，我会更加注重实践，注重多练，多积累。

数据结构—串的模式匹配

数据结构—串的模式匹配数据结构—串的模式匹配1：引言1.1 背景在计算机科学中，模式匹配是一个常见的问题，涉及到在给定的文本字符串中查找特定的模式串。

串的模式匹配是一种重要的算法，广泛应用于字符串处理、数据查询和自然语言处理等领域。

1.2 目的本文档旨在介绍串的模式匹配算法的基本原理和常用的实现方法，以及其在实际应用中的一些应用场景。

通过阅读本文档，读者将能够理解串的模式匹配算法的工作原理，并能够根据具体的应用需要选择合适的算法进行实现。

2：基本概念2.1 字符串字符串是由字符组成的有限序列，在计算机中通常以字符数组或字符指针的形式来表示。

字符串是计算机科学中常用的数据类型之一，用于表示文本数据。

2.2 模式串模式串是在字符串匹配中需要查找的特定模式，它是一个想要在文本串中查找的子串。

3：算法实现3.1 简单匹配算法简单匹配算法，也称为朴素匹配算法，是最简单直观的一种模式匹配算法。

它的基本思想是，从文本串的第一个字符开始，逐个字符地与模式串进行匹配，如果匹配失败，则从文本串的下一个字符重新开始匹配。

3.2 KMP算法KMP算法是一种高效的模式匹配算法，它利用了模式串本身的信息来加速匹配过程。

该算法基于一个重要观察结果，即当模式串在某一位置匹配失败时，它的前缀与后缀可能存在一定的重叠，从而可以避免无效的匹配。

3.3 Boyer-Moore算法Boyer-Moore算法是一种高效的模式匹配算法，它利用了模式串和文本串的不同之处来加速匹配过程。

该算法在匹配失败时，根据坏字符规则和好后缀规则，可以跳过一定数量的字符，从而避免无效的匹配。

4：应用场景4.1 文本搜索串的模式匹配算法可以应用于文本搜索中，用于在大量文本数据中查找特定模式的出现位置。

4.2 数据处理串的模式匹配算法可以应用于数据处理中，用于对字符串数据进行匹配处理、替换等操作。

4.3 自然语言处理串的模式匹配算法可以应用于自然语言处理中，用于识别特定语义模式或词组的出现。

实验三串的模式匹配

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

数据结构实验报告-串与模式匹配

return -1;
}
//输岀next值
int Dis_next (int next[], char *t) {
int i;
for(i=l;i<=t[0];i++)
{
printf (，z%d/z, next Li]);
}
printf("\n"); return next[i];
}
//模式串求next值
//求串长
int StrLength(char *s)
{
int i二0;
wh订e(s[i] !=' \0‘)
i++；
return (i);
}
int Change(char *s)
{
int i;
for(i=StrLength (s)-1; i>=0; i―)
{
s[i+l]=s[i];
}
s E0]=StrLength (s);
else
return T;
int main(void)
printfC(1)建立abcabcdabcdeabcdefabcdefg目标串s和abcdeabcdefab模式串t\n");
char s匚=/，abcabcdabcdeabcdefabcdefg/";
char t[」=?/abcdeabcdefabz，;
{
int i=pos,j=l;
while(i<=s[0]&&j<=t[0])
if (j=0 |s[i]==t[j])
{
i++；
j++;
}
else

串的模式匹配串的模式匹配

实验题目：串的模式匹配一、实验目的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；输出：五、实验心得答：通过本次的实验，让我加深了理解了串的操作。

字符串对比算法

实验三、串的模式匹配赵俊1041901229 一、实验内容在给出主串S和模式T(子串)后，实现模式匹配。

若在S中含有模式T,返回子串T在主串S中首次出现的位置。

若T不是S的子串，则匹配失败，返回0。

要求：1. 在串的顺序存储结构下，采用朴素的模式匹配算法BF实现；2．在串的顺序存储结构下，选用模式匹配的KMP算法实现；3．考虑在链式存储结构下，试实现串的模式匹配。

二、实验目的1. 掌握串的顺序存储结构；2. 掌握串的模式匹配的BF算法；3. 掌握串的模式匹配的实现方法；4．了解模式匹配的KMP算法及失效函数的计算方法；5．了解串的链式存储结构三、实验代码#include<stdio.h>#include<tchar.h>int KMPSearch(const char * main_str, const char * sub_str, int * next);void CalculateNext(const char * sub_str, int len, int * next);int BFSearch(const char *main_str,const char *sub_str);#include"stdafx.h"#include<iostream>#include<string>using namespace std;int _tmain(int argc, _TCHAR* argv[]){char*a="abcdeabcdeabc";char *b="eabc";BFSearch(a,b);int next[100];CalculateNext(b,5,next);KMPSearch(a,b,next);return 0;}int BFSearch(const char *main_str,const char *sub_str){int i=0;int j=0;int main_len=strlen(main_str);int sub_len=strlen(sub_str);while((i<main_len)&&(j<sub_len)){if( main_str[i] == sub_str[j]){j++;i++;}else{j=1;i=i-j+2;}}if(j == sub_len){return i-sub_len;}return -1;}int KMPSearch(const char * main_str, const char * sub_str, int * next) {int i=0;int j=0;int main_len=strlen(main_str);int sub_len=strlen(sub_str);while((i<main_len)&&(j<sub_len)){if(j == -1 || main_str[i] == sub_str[j]){j++;i++;}else{j=next[j];}}if(j == sub_len){return i-sub_len;}return -1;}void CalculateNext(const char * sub_str, int len, int * next){int k=-1;int j=0;next[0]=-1;while(j<len){if(k == -1 || sub_str[k] == sub_str[j]){k++;j++;next[j]=k; }else{k=next[k];}}}四、调试和运行结果。

大数据结构串与模式匹配

常熟理工学院《数据结构与算法》实验指导与报告书_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串的模式匹配算法。

实验三____串的模式匹配

串的模式匹配算法

串的模式匹配算法实验报告

串的模式匹配

北邮数据结构实验报告

数据结构实验总结及心得体会

串匹配算法实验报告

数据结构—串的模式匹配

第3章 蛮力法——串的模式匹配

串及其应用的实验报告

串的模式匹配

实验三-串的模式匹配

串操作实验报告

字符串的模式匹配实验报告

数据结构—串的模式匹配

实验三串的模式匹配

数据结构实验报告-串与模式匹配

串的模式匹配串的模式匹配

字符串对比算法

大数据结构串与模式匹配

第3章蛮力法——串的模式匹配