kmp算法实验报告
模式匹配KMP算法研究报告
模式匹配的KMP算法研究学生姓名：黄飞指导老师：罗心摘要在计算机科学领域，串的模式匹配<以下简称为串匹配）算法一直都是研究焦点之一。
在拼写检查、语言翻译、数据压缩、搜索引擎、网络入侵检测、计算机病毒特征码匹配以及DNA序列匹配等应用中，都需要进行串匹配。
串匹配就是在主串中查找模式串的一个或所有出现。
在本文中主串表示为S=s1s2s3…sn，模式串表示为T=t1t2…tm。
串匹配从方式上可分为精确匹配、模糊匹配、并行匹配等，著名的匹配算法有BF算法、KMP算法、BM算法及一些改进算法。
本文主要在精确匹配方面对KMP算法进行了讨论并对它做一些改进以及利用改进的KMP来实现多次模式匹配。
关键字：模式匹配；主串；模式串；KMP算法Research and Analysis of KMP Pattern MatchingAlgorithmStudent:Huangfei Teacher:LuoxinAbstract In computer science,String pattern matching(Hereinafter referred to as the string matching>algorithmis always the focus of the study.In thespell check, language translation, data compression, search engine, thenetwork intrusion detection system, a computer virus signature matching DNAsequences and the application in the match,matched to string matching.String matching is in search of a string of pattern or all appear.In this paper, the string is S = s1s2s3... Sn, string pattern for T = t1t2... tm.String matching way can be divided from the accurate matching, fuzzy matching, parallel matching etc., the famous matching algorithms are KMP algorithm, BF algorithm, the algorithm and some BM algorithm.This paper in precise KMP algorithm for matching aspects are discussed and some improvement on it and using the improved KMP to realize the multiple pattern matching.Key words: pattern matching, The string。
模式匹配KMP算法实验报告
实验四：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算法所在。
串匹配算法实验报告
一、实验目的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. 两种算法的性能对比为了对比两种算法的性能，我们分别测试了不同的文本串和模式串长度，并记录了运行时间。
数据结构实验报告 模式匹配算法
return 1; } datatype DeQueue(SeqQueue *q) { datatype x; if(q->front==q->rear) { printf("\nempty!");return 0;} x=q->data[q->front]; q->front=(q->front+1)%max; return x; } void display(SeqQueue *q) { int s; s=q->front; if(q->front==q->rear) printf("empty!"); else while(s!=q->rear) { printf("->%d",q->data[s]); s=(s+1)%max; } printf("\n"); } main() { int a[6]={3,7,4,12,31,15},i; SeqQueue *p; p=InitQueue(); for(i=0;i<6;i++) EnQueue(p,a[i]); printf("output the queue values:"); display(p); printf("\n"); EnQueue(p,100);EnQueue(p,200);
ห้องสมุดไป่ตู้
元素并显示结果为4 ，12， 31， 15 ，100 ，200。
七、具体程序 #include "stdio.h" #include "conio.h" #define max 100 typedef int datatype; typedef struct { datatype data[max]; int front; int rear; }SeqQueue; SeqQueue *InitQueue() { SeqQueue *q; q=(SeqQueue *)malloc(sizeof(SeqQueue)); q->front=q->rear=0; return q; } int QueueEmpty(SeqQueue *q) { if (q->front==q->rear) return 1; else return 0; } int EnQueue(SeqQueue *q,datatype x) { if((q->rear+1)%max==q->front) {printf("\nfull！");return 0;} q->data[q->rear]=x; q->rear=(q->rear+1)%max;
KMP算法实验报告
}
六
第一步，对模式串中求next操作的逐一检查。
第二步：对KMP匹配算法进行逐一检查
七
八
j=next[j]; //消除了指针i的回溯
}
if(j==strlen(p))
return i+1-strlen(p);
}
return -1;
}
int main()
{
char s[100]="acabaabaabcacaabc";
char p[100]="baabcac";
printf("在第%d个元素时匹配成功\n",KMPMatch(s,p));
}
}
int KMPMatch(char *s,char *p)
{
int next[100];
int i,j;
i=0;
j=0;
getNext(p,next);
while(i<strlen(s))
{
if(j==-1||s[i]==p[j])
{
i++;
j++;
}
else
{
printf("此时主串是第%d个元素，%c。模式串是第%d个元素，%c\n",i+1,s[i],j+1,p[j]);
#include <stdlib.h>
#include <conio.h>
#defineCHUNKSIZE 80
void getNext(char *p,int *next)
{
int j,k,x;
next[0]=-1;
计算机算法实验报告BF和KMP
天津市大学软件学院实验报告课程名称：串匹配算法实验姓名：***学号：**********班级：业务1114串匹配问题一、实验题目：给定一个主串，在该主串中查找并定位任意给定字符串。
二、实验目的：(1)深刻理解并掌握蛮力法的设计思想；(2)提高应用蛮力法设计算法的技能；(3)理解这样一个观点：用蛮力法设计的算法，一般来说，经过适度的努力后，都可以对算法的第一个版本进行一定程度的改良，改进其时间性能。
三、实验分析：串匹配问题的BF算法1 在串S中和串T中设比较的下标i=1和j=1;2 循环直到S中所剩字符个数小于T的长度或T中所有字符均比较完2.1 k=i2.2 如果S[i]=T[j],则比较S和T的下一字符,否则2.2 将i和j回溯(i=k+1; j=1)3 如果T中所有字符均比较完,则匹配成功,返回k否则匹配失败,返回0时间复杂度：设匹配成功发生在si处，则在i-1趟不成功的匹配中比较了（i-1）m次，第i趟成功匹配共比较了m次，所以总共比较了i m次，因此平均比较次数是：pi(i m)=(i m)=一般情况下，m<<n,因此最坏情况下时间复杂度是Ο(n m)。
串匹配问题的KMP算法实现过程：在串S和串T中高比较的起始下标i和j；循环直到S中所剩字符小于T的长度或T的所有字符均比较完（如果S[i]=T[j],则继续比较S和T的下一个字符；否则将j向右滑动到next[j]位置，即j=next[j];如果j=0,则将i和j分别+1，准备下趟比较，至于其中的next在此不作详细讲解）；如果T中所有字符均比较完，则匹配成功，返回匹配的起始下标；否则匹配失败，返回0。
时间复杂度：Ο(n m)，当m<<n时，KMP算法的时间复杂性是Ο(n)。
四、实验所用语言和运行环境C++，运行环境Microsoft Visual C++ 6.0五、实验过程的原始记录BF算法程序代码#include<iostream.h>#include<string>void main(){cout<<"请输入主串并且以0和回车结束"<<endl;char s[100];char t[100];for(int m=0;m<100;m++){cin>>s[m];if(s[m]=='0'){s[m]='\0';break;}}cout<<"您输入的主串为：";for(int o=0;o<strlen(s);++o){cout<<s[o];}cout<<endl;cout<<"主串长度：";cout<<strlen(s);cout<<endl<<endl;cout<<"请输入子串并且以0和回车结束"<<endl;for(int n=0;n<100;n++){cin>>t[n];if(t[n]=='0'){t[n]='\0';break;}}cout<<"您输入的子串为：";for(int a=0;a<strlen(t);++a){cout<<t[a];}cout<<endl;cout<<"子串长度：";cout<<strlen(t);cout<<endl;cout<<endl<<"++++++++BF算法++++++++"<<endl;int i,j,k,y=0;for(i=0;i<strlen(s)-strlen(t)+1;){k=i;for(j=0;j<strlen(t);)if(s[i]==t[j]){if(j==strlen(t)-1){cout<<"找到了相同的字串：";cout<<"位置在主串的第"<<i-j+1<<"的位置上";cout<<endl;y=1;break;}++i;++j;}else{j=0;break;}}i=k+1;if(y==1)break;}if(i==strlen(s)-strlen(t)+1&&j!=strlen(t)-1){cout<<"没有找到可以匹配的子串"<<endl;}}程序执行结果：查找到了子串没有查找到子串程序代码#include<iostream.h>#include<string>//前缀函数值,用于KMP算法int GETNEXT(char t[],int b){int NEXT[10];NEXT[0]=-1;int j,k;j=0;k=-1;while(j<strlen(t)){if ((k==-1)||(t[j]==t[k])){j++;k++;NEXT[j]=k;}else k=NEXT[k];}b=NEXT[b];return b;}int KMP(char s[],char t[]){int a=0;int b=0;int m,n;m=strlen(s); //主串长度n=strlen(t); //子串长度cout<<endl<<"+++++++++KMP算法++++++++++++"<<endl;while(a<=m-n){while(s[a]==t[b]&&b!=n){a++;b++;}if(b==n){cout<<"找到了相应的子串位置在主串："<<a-b+1<<endl;return 0;}b=GETNEXT(t,b);a=a-b;if(b==-1) b++;}cout<<"没有找到匹配的子串！"<<endl;return 0;}void main(){cout<<"请输入主串并且以0和回车结束"<<endl;char s[100];char t[100];for(int m=0;m<100;m++){cin>>s[m];if(s[m]=='0'){s[m]='\0';break;}}cout<<"您输入的主串为：";for(int o=0;o<strlen(s);++o){cout<<s[o];}cout<<endl;cout<<"主串长度：";cout<<strlen(s);cout<<endl<<endl;cout<<"请输入子串并且以0和回车结束"<<endl;for(int n=0;n<100;n++){cin>>t[n];if(t[n]=='0'){t[n]='\0';break;}}cout<<"您输入的子串为：";for(int a=0;a<strlen(t);++a){cout<<t[a];}cout<<endl;cout<<"子串长度：";cout<<strlen(t);cout<<endl;KMP(s,t);}程序执行结果：查找到子串没有查到子串。
字符匹配查找实验报告(3篇)
第1篇一、实验目的1. 理解字符匹配查找算法的基本原理。
2. 掌握几种常见的字符匹配查找方法，如暴力法、KMP算法、Boyer-Moore算法等。
3. 分析比较不同查找算法的效率，提高编程能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验原理字符匹配查找是指在一个文本中查找一个特定的子串，并返回子串在文本中的起始位置。
本实验主要研究了以下几种查找算法：1. 暴力法：逐个比较文本中的每个字符与子串的第一个字符，若匹配则继续比较下一个字符，否则回退一位重新比较。
2. KMP算法：通过预处理子串，构建一个部分匹配表，当主串与子串不匹配时，利用部分匹配表确定子串的下一个位置。
3. Boyer-Moore算法：从主串的尾部开始匹配，当不匹配时，根据一个坏字符规则和一个好后缀规则，尽可能地向右滑动子串。
四、实验内容1. 暴力法实现2. KMP算法实现3. Boyer-Moore算法实现4. 性能比较五、实验步骤1. 实现暴力法查找算法2. 实现KMP算法查找算法3. 实现Boyer-Moore算法查找算法4. 编写性能比较代码，对比三种算法的查找效率六、实验结果与分析1. 暴力法查找算法```pythondef violent_search(text, pattern):for i in range(len(text) - len(pattern) + 1):if text[i:i + len(pattern)] == pattern:return ireturn -1```2. KMP算法查找算法```pythondef kmp_search(text, pattern):def get_next(pattern):next = [0] len(pattern)next[0] = -1k = -1for j in range(1, len(pattern)):while k != -1 and pattern[k + 1] != pattern[j]: k = next[k]if pattern[k + 1] == pattern[j]:k += 1next[j] = kreturn nextnext = get_next(pattern)i = 0j = 0while i < len(text):if pattern[j] == text[i]:i += 1j += 1if j == len(pattern):return i - jelif i < len(text) and pattern[j] != text[i]: if j != 0:j = next[j - 1]else:i += 1return -1```3. Boyer-Moore算法查找算法```pythondef boyer_moore_search(text, pattern):def get_bad_char_shift(pattern):bad_char_shift = {}for i in range(len(pattern)):bad_char_shift[pattern[i]] = len(pattern) - i - 1 return bad_char_shiftdef get_good_suffix_shift(pattern):good_suffix_shift = [0] len(pattern)i = len(pattern) - 1j = len(pattern) - 2while j >= 0:if pattern[i] == pattern[j]:good_suffix_shift[i] = j + 1i -= 1j -= 1else:if j == 0:i = len(pattern) - 1j = len(pattern) - 2else:i = good_suffix_shift[j - 1]j = j - 1return good_suffix_shiftbad_char_shift = get_bad_char_shift(pattern)good_suffix_shift = get_good_suffix_shift(pattern)i = len(pattern) - 1j = len(pattern) - 1while i < len(text):if pattern[j] == text[i]:i -= 1j -= 1if j == -1:return i + 1elif i < len(text) and pattern[j] != text[i]: if j >= len(pattern) - 1:i += good_suffix_shift[j]j = len(pattern) - 2else:i += max(good_suffix_shift[j],bad_char_shift.get(text[i], -1))return -1```4. 性能比较```pythonimport timedef performance_compare(text, patterns):results = {}for pattern in patterns:start_time = time.time()result = violent_search(text, pattern)results[pattern] = (result, time.time() - start_time)start_time = time.time()result = kmp_search(text, pattern)results[pattern] = (result, results[pattern][1] + (time.time() - start_time))start_time = time.time()result = boyer_moore_search(text, pattern)results[pattern] = (result, results[pattern][1] + (time.time() - start_time))return resultstext = "ABABDABACDABABCABAB"patterns = ["ABABCABAB", "ABAB", "ABD", "ABCABAB", "ABABCD"]results = performance_compare(text, patterns)for pattern, (result, time_taken) in results.items():print(f"Pattern: {pattern}, Result: {result}, Time taken:{time_taken:.6f} seconds")```实验结果如下：```Pattern: ABABCABAB, Result: 0, Time taken: 0.000100 secondsPattern: ABAB, Result: 0, Time taken: 0.000100 secondsPattern: ABD, Result: 4, Time taken: 0.000100 secondsPattern: ABCABAB, Result: 6, Time taken: 0.000100 secondsPattern: ABABCD, Result: -1, Time taken: 0.000100 seconds```从实验结果可以看出，KMP算法和Boyer-Moore算法在查找效率上明显优于暴力法。
模式匹配实验报告
一、实验目的本次实验旨在让学生熟悉并掌握模式匹配的基本概念、算法及其应用。
通过实验，学生能够了解模式匹配算法的原理，掌握几种常见的模式匹配算法（如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)。
顺序表链表KMP实验报告
附件（四）深圳大学实验报告课程名称：数据结构实验与课程设计实验项目名称：顺序表、链表、堆栈队列、串KMP算法学院：专业：指导教师：报告人：学号：班级：实验时间：实验报告提交时间：教务处制第1行输出创建后的顺序表内容，包括顺序表实际长度和数据（完成）每成功执行一次操作（插入或删除），输出执行后的顺序表内容（完成）每成功执行一次查找，输出查找到的数据（完成）如果执行操作失败（包括插入、删除、查找等失败），输出字符串error，不必输出顺序表内容（完成）2.Problem B: DS顺序表--连续操作目的：(1)建立顺序表的类，属性包括：数组、实际长度、最大长度（设定为1000）(2)实现连续多个插入，即从位置i开始插入多个数据(3)实现连续多个删除，即从位置i开始删除多个数据要求：Input第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据（完成）第2行先输入i表示插入开始的位置，再输入k表示有k个插入数据，接着输入k 个数据（完成）第3行先输入i表示删除开始的位置，再输入k表示要删除k个数据（完成）Output顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开（完成）第1行输出创建后的顺序表内容（完成）第2行输出执行连续插入后的顺序表内容（完成）第3行输出执行连续删除后的顺序表内容（完成）(2)属性包括：data数据域、next指针域(3)操作包括：插入、删除、查找(4)注意：单链表不是数组，所以位置从1开始对应首结点，头结点不放数据要求：Input第1行先输入n表示有n个数据，接着输入n个数据（完成）第2行输入要插入的位置和新数据（完成）第3行输入要插入的位置和新数据（完成）第4行输入要删除的位置（完成）第5行输入要删除的位置（完成）第6行输入要查找的位置（完成）第7行输入要查找的位置（完成）Output数据之间用空格隔开，（完成）第1行输出创建后的单链表的数据（完成）每成功执行一次操作（插入或删除），输出执行后的单链表数据（完成）每成功执行一次查找，输出查找到的数据（完成）如果执行操作失败（包括插入、删除、查找等失败），输出字符串error，不必输出单链表（完成）2.Problem B: DS单链表--结点交换目的：(1)用C++实现含头结点的单链表，然后实现单链表的两个结点交换位置。
kmp算法实验报告
数据结构实验报告学院软件学院年级2009级班级班学号姓名2010 年 3 月24 日目录一、实验内容 (1)二、实验过程 (X)三、实验结果 (X)一、实验内容：1、实验题目：KMP算法2、实验要求：实现教材中字串比较kmp算法，比较模式串abaabcac与主串acabaabaabcacaabc。
3、实验目标：了解并掌握串的类型定义和基本操作，并在此基础上实现kmp算法。
了解kmp算法的基本原理和next函数的使用。
二、实验过程：1、任务分配2、设计思想（1）KMP算法：在模式匹配中，每当一趟匹配过程出现字符比较不等时，不需要回溯i指针，而是利用已经得到的“部分匹配”的结果将模式向右滑动尽可能远的一段距离之后，继续进行比较。
（2）next函数：看成一个模式匹配问题，整个模式串既是主串又是模式串，可仿照KMP算法。
3、需求分析(1) 输入的形式和输入值的范围：输入主串S,模式串T，位置pos(2) 输出的形式：模式串在主串中开始匹配的位置i(3) 程序所能达到的功能：利用kmp算法完成模式串和主串的模式匹配，并输出模式串在主串中开始匹配的位置(4) 测试数据：S=acabaabaabcacaabcT=abaabcacPos=64、概要设计1).抽象数据类型Class String()定义字符串Int StrLength()返回串的长度V oid get_next()求模式串T的next函数值并存入nextint kmp()利用模式串T的next函数求出T在主串S中第pos个字符之后的位置的KMP算法2).算法a.kmp算法模块：实现主串和模式串的模式匹配b.next函数模块：实现模式串自身的模式匹配，并存入nxet函数中c.接收处理命令（初始化数据）5、详细设计程序代码（含注释）6、调试分析（1）调试中的问题分析：a.（2）算法的时空分析：在利用简单的Index()函数进行模式匹配时，虽然易于理解，但是该算法效率很低。
《kmp算法报告》word版
摘要关键词匹配(Keyword Matching)有时也称为模式匹配(Pattern Matching)，是计算机科学中一个基本问题，也是一个经典的算法问题。
该算法目前被广泛用于信息处理、网络信息过滤、入侵检测系统和生物信息计算的基因序列比较等工作中。
本文首先分别介绍单模式匹配和多模式匹配的经典算法，单模式匹配算法主要分析了KMP算法和BM算法，多模式匹配算法详细分析了Wu-Manber多模式匹配算法，并对其进行了改进，最后通过实验对几种算法的复杂度进行了比较。
1.引言简单的说关键词匹配问题就是从给定的文本(Text)中，找出所有的需要匹配的模式(Pattern)。
一类匹配问题是预先知道文本，再根据动态给出的模式进行匹配，例如搜索引擎预先收集Web页信息，再跟据用户输入的关键词进行匹配查找，处理这类问题需要对已知的文本做一些处理来加速匹配过程，一般采用对文本加索引的方式；另一类匹配问题是预先知道模式，在不同的文本中进行匹配，例如用关键词过滤信息，根据特征码检查病毒等都属于这类问题。
根据待匹配的关键词的个数又可以分为单模式匹配和多模式匹配。
另外根据匹配的方式还可以分为基于字符比较匹配(character parison)和基于非字符比较匹配(主要将字符串看作bit串来处理和一些数值型的方法)两种。
本文要讨论的是预先知道模式的情况下基于字符比较的模式匹配问题，本文首先分别介绍单模式匹配和多模式匹配的经典算法，其中详细分析了Wu-Manber多模式匹配算法，并对其进行了改进，最后通过实验对几种算法的复杂度进行了比较。
2.单模式匹配算法单模式匹配就是在给定的文本(Text)中对给定的单个关键词样本(Pattern)进行搜索，并且返回所有的匹配。
最原始的匹配算法是平凡算法，即用关键从文本起始位置开始比较，每次匹配不论成功与否都将关键词在当前文本处右移一位。
平凡算法在正确性上是没有问题的，但是由于每次只将Pattern右移一位导致匹配时间很长。
编码_匹配算法实验报告(3篇)
第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. 实现方法：首先，计算坏字符表和好后缀表；然后，遍历主串，与模式串的第一个字符比较，若匹配，则继续比较后续字符；若不匹配，则根据坏字符表和好后缀表进行回退。
KMP算法的Java实现例子以及测试分析
KMP算法的Java实现例子以及测试分析背景简介：KMP算法用来处理字符串匹配的。
给你A,B两个字符串，检查B串是否是A串的子串，类似于Java的String.indexOf("")。
之所以叫做KMP，是因为这个算法是由Knuth、Morris、Pratt三个提出来的，取了这三个人的名字的头一个字母。
原理介绍：找到匹配失败时的最合适的回退位置，而不是简单的回退到子串的第一个字符（常规的枚举查找方式，是简单的回退到子串的第一个字符，接下来准备写一篇KMP算法的性能分析Java实现实例），即可提高查找的效率。
因此为了找到这个合适的位置，先对子串预处理，从而得到一个回退位置的数组。
过多的理论就不介绍了。
总体而言比较简单，KMP算一个经典的算法例子，很多笔试、面试也会问起。
现总结一下，放在这里供大家参考、交流，希望对大家有所帮助，下面直接给出实现例子，测试与分析也包含其中。
一、一个文件源代码KMP.java源代码为：package algorithm.kmp;/*** KMP算法的Java实现例子与测试、分析* @author 崔卫兵* @date 2009-3-25*/public class KMP {/*** 对子串加以预处理，从而找到匹配失败时子串回退的位置* 找到匹配失败时的最合适的回退位置，而不是回退到子串的第一个字符，即可提高查找的效率* 因此为了找到这个合适的位置，先对子串预处理，从而得到一个回退位置的数组* @param B，待查找子串的char数组* @return*/public static int[] preProcess(char [] B) {int size = B.length;int[] P = new int[size];P[0]=0;int j=0;//每循环一次，就会找到一个回退位置for(int i=1;i<size;i++){//当找到第一个匹配的字符时，即j>0时才会执行这个循环//或者说p2中的j++会在p1之前执行（限于第一次执行的条件下）//p1while(j>0 && B[j]!=B[i]){j=P[j];}//p2，由此可以看出，只有当子串中含有重复字符时，回退的位置才会被优化if(B[j]==B[i]){j++;}//找到一个回退位置j，把其放入P[i]中P[i]=j;}return P;}/*** KMP实现* @param parStr* @param subStr* @return*/public static void kmp(String parStr, String subStr) {int subSize = subStr.length();int parSize = parStr.length();char[] B = subStr.toCharArray();char[] A = parStr.toCharArray();int[] P = preProcess(B);int j=0;int k =0;for(int i=0;i<parSize;i++){//当找到第一个匹配的字符时，即j>0时才会执行这个循环//或者说p2中的j++会在p1之前执行（限于第一次执行的条件下）//p1while(j>0 && B[j]!=A[i]){//找到合适的回退位置j=P[j-1];}//p2 找到一个匹配的字符if(B[j]==A[i]){j++;}//输出匹配结果，并且让比较继续下去if(j==subSize){j=P[j-1];k++;System.out.printf("Find subString '%s' at %dn",subStr,i-subSize+1);}}System.out.printf("Totally found %d times for '%s'.nn",k,subStr);}public static void main(String[] args) {//回退位置数组为P[0, 0, 0, 0, 0, 0]kmp("abcdeg, abcdeh, abcdef!这个会匹配1次","abcdef");//回退位置数组为P[0, 0, 1, 2, 3, 4]kmp("Test ititi ititit! Test ititit!这个会匹配2次","ititit");//回退位置数组为P[0, 0, 0]kmp("测试汉字的匹配，崔卫兵。
KMP算法的实验报告
实验报告课程名称：数据结构与算法
实验4：实现KMP算法
四：实验步骤与结果：
结果是：
五．实验讨论
本身自己基础很不好，造成实验过程中有很多麻烦。
开始的时候虽然也用到书本上的算法，可是我自己改了下，第一个字符存的不是长度，到后面老是内存出错。
现在用的完全是书本上的算法，只是在原来写的基础上，多了串的复制，这样的话，就可以知道串的第一个存储的是长度。
用到了很久都没想到的strlen函数。
这样求解变得十分简单，还用到了typedef unsigned char SString[MAXTRLEN+1];这个使得整个变得简洁了！还有思维变得很固定了，只是按照书本上的去写，自己想的老是写不出来。
kmp算法实验报告
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，前面自身部分匹配的部分不止两个，那应该往前跳到第几个呢？最近的一个，也就是说尽可能的向右滑移最短的长度。
数据结构实验报告——KMP算法
实验名称：Kmp 算法
实验人：
学号：
按要求完成的输入/输出信息 完成日期 自我评价
2．输入数据应提示输入内容与输入格式。 3． 输出数据要加以说明。 4．程序应注意使用注释语句。 5．注意程序的健壮性和交互性，养成良好的编程习惯。 6．在“网上课程”上提交 C 源程序。 7．交打印稿（或电子稿）的实验报告（完成日期：11 月 17 日） 。 三．实验内容：(提供每一个实验题目的算法描述、程序代码) 实验内容： 内容 [问题描述 问题描述] 问题描述 选做 1： 求出子串（模式串）的 next，利用 kmp 算法实验模式与主串的匹配算法。 要求：由键盘输入主串及子串的值， （1）输出子串的 next 值（注：next 的初始值为： next[1]=0）（2）输出子串在主串中首次出现的位置。 。 选做 2： 实现串的基本运算（求（1）串的长度、 （2）串的连接、 （3）串的比较） 。 要求： （1）由键盘输入一个串的值，输出串的长度。 （2）由键盘输入两个串的值，输出第一个串+第二个串的值。 （3）由键盘输入两个串的值，比较两串是否相等，输出相关提示信息。 [算法描述 算法描述] 算法描述 算法提示： 1．生成模式串的 next 函数 2．从第 1 个字符开始，进行模式串与主串的比较， 3．如果出现失配，将模式串的第 next[j]位置开始，继续与主串进行比较。
深 圳 大 学 实 验 报 告
课程名称： 课程名称：
数据结构
实验项目名称： 实验项目名称：
实验三： 实验三：Kmp 算法
ห้องสมุดไป่ตู้学院： 学院：
计算机与软件学院
专业： 专业：
计算机
指导教师： 指导教师：
蔡平
报告人： 报告人： 郑静宏
KMP实验报告
KMP实验报告实验报告题⽬：编制字符串匹配的KMP算法班级：理科实验四班姓名：⽊三学号：****** 完成⽇期：2016.4.17⼀、需求分析1.字符串匹配试求⼦串位置的定位函数，普通的字符串匹配函数时间复杂度较⼤达到了O（m*n），⽽KMP算法则可以将时间复杂度简化到O（m+n）。
2.本演⽰程序中，字符串的元素为除换⾏、退格等字符外的其他字符，字符串长度<=MAXSIZE，字符串的输⼊的形式为string[0]储存长度，从string[1]开始存储字符，并以’\0’做结束标志，字符串中字符顺序不限，且允许出现重复字符，不能出现⾮法字符。
输⼊两个字符串后，输⼊⼀个整形数pos，pos<=MAXSIZE，pos的值必须合法。
输出的结果为⼀个整形数，表⽰，从第⼀个字符串的pos位置开始，之后的⼦串能否与第⼆个字符串匹配，若能，输出匹配⾸地址的编号，若不能，输出0。
3.程序执⾏的命令包括：1）构造字符串1；2）构造字符串2；3）kmp算法；4）得到next[]；4.测试数据1）string1=’abababab’ string2=’aba’ pos=1 output=1;2）string1=’abababab’ string2=’aba’ pos=6 output=0;⼆、概要设计KMP算法是D.E.Knuth与V.R.Pratt和J.H.Morris同时发现的⼀种模式匹配的⾼效算法，，可以在O（m+n）的时间数量级上完成串的模式匹配操作。
其改进在于：每当⼀趟匹配过程中出现的字符⽐较不等时，不需要回溯i指针，⽽是利⽤已经得到的?部分匹配?的结果将模式向右?滑动?尽可能远的⼀段距离后，继续进⾏⽐较。
为实现上述上述程序功能，应以串的定长顺序存储表⽰来存放字符串，且需要串的抽象数据类型。
1.串的定长顺序存储表⽰为：#define MAXSTRLEN 255//⽤户可在255以内定义最⼤串长typedef char SString[MAXSTRLEN+1];//0号单元存放串的长度2.串的抽象数据类型定义为：ADT String{数据对象：D={ai|ai∈CharacterSet,i=1,2,...,n,n>=0}数据关系：R1={|ai-1,ai∈D,i=1,2,...,n}基本操作：GetString(SString &S)初始条件：存在串的指针。
KMP模式匹配算法的研究分析
进行计算 , 结果表明 , 改进后的 K M P 算法 和 KM P 算法的时间复杂度均为 O( m + n) , 但改进后 算法的平均 比较次数约 为未 改进算法的平均比较次数的 0. 833 倍 , 因此改进后的 KM P 算法更能提高字符串模式匹配的工作效率。 关键词 模式匹配 ; K M P 算法 ; 算法 ; nex t 函数 T P301 中图分类号
Research and Analysis of KMP Pattern Matching Algorithm
Ya ng Z hanha i ( Comput er Center , Y an an U nv ersity , Y an an 716000)
Abstract
T his paper analyzes an improv ed metho d of K M P algo rit hm and calculat es the complex ity of the alg or ithm
法中的 i 不是保持不变 , 而是增加了, 这就意味着 加快了模式匹配的进度。 4. 2 算法的分析 KM P 算法时 间复杂度 可分两 部分来 进行分 析 , 一部分是扫描算法中 T [ i ] 与 P[ j ] 的比较次数 , 另一部分是根据模式来计算 nex t [ j ] 的工作量。计 算 nex t [ j ] 与模 P 的长度 m 有关, 与主串无关 , 其 算法时间复杂度为 O( m) 。因为 KM P 算法与改进 的 KM P 算法涉及的计算 nex t [ j ] 的工作量相同 , 所以这两个算法的时间复杂度主要区别在是否有 # i f ( i+ j - k m& & P [ j ] ! = T [ i+ j - k] ) i = i+ j - k; ∃ 这句上, 设 p ( m, n) 与 q ( m, n) 分别为 KM P 算法和改进 KM P 算法中 T [ i] 与 P[ j ] 的平均比较 次数, 则考虑到: if 语句的两个分支出现的概率相等 , 平均出现 次数为 n/ 2; else 分支语句取得 n/ 2 个 nex t[ j ] 后, i 不得增 加却又投入了比较 , 使得在同一个 i 位置上增加了 一次比较, 因此: p ( m, n) = n + n/ 2+ m = 1. 5n+ m 。 在改进的 KMP 算法中的语句# i f ( i + j - k n& & P[ j ] ! = T [ i + j - k] ) i= i + j - k; ∃ 的平均 出现次数为 n/ 2, 该分支语句使得 i 向右# 滑动∃ 的 机会增加了 n/ 4 次, 这些机会不是使 i 保持不变 , 而是使 i 朝着匹配处前进了亦即促进了模式匹配 的进度 , 因此 : q( m, n) = 1. 5 n- n/ 4+ m = 1 . 25n + m 令 m 为恒定值 , 故而 q( m, n) 1 . 25n + m = lim = 0. 833 p ( m, n) n % & 1. 5 n+ m 可见, p ( m, n) 与 q( m, n) 同阶 , 它们的时间复
数据结构实验报告
数据结构实验报告数据结构实验报告课题名称：数据结构实验课学号：姓名：班号：2015年12⽉⽬录⼀、实验⽬的，要求及任务 (4)1.1⽬的1.2要求1.3任务⼆、算法设计、程序运⾏结果 (4)2.1 实验⼀ (4)1题⽬2算法设计（1）设计思路（2）程序关系图（3）实验功能描述3实验数据与结果2.2实验⼆ (11)1题⽬2算法设计（1）设计思路（2）程序关系图（3）实验功能描述3 实验数据与结果2.3实验三 (13)1题⽬2算法设计（1）设计思路（2）程序关系图2.4实验四 (18)1题⽬2算法设计（1）设计思路（2）程序关系图（3）实验功能描述3 实验数据与结果2.5实验五 (24)1题⽬2算法设计（1）设计思路（2）程序关系图（3）实验功能描述3 实验数据与结果三、实验⼩结 (31)⼀、实验⽬的、要求及任务1.1⽬的通过实验，使学⽣熟悉常⽤的数据结构，掌握其算法设计⽅法，重点掌握单链表、栈和队列、⼆叉树、图等⼏种数据结构的设计与应⽤。
1.2要求进⾏数据结构应⽤有关的程序设计，使⽤VC++环境(或其他C编译环境)上机测试通过，并提交实验报告。
1.3任务必做题（教材）：P63 上机实验题2 实验题2.5、2.6、2.7P96 上机实验题3 实验题3.3、3.5/3.8P119 上机实验题4 实验题4.3P152 上机实验题6 实验题6.2、6.4P202 上机实验题7 实验题7.1、7.2、7.4P152 上机实验题8 实验题8.1、8.2、8.5选做题：1、选部分作业上机验证；2、教材上机实验2~8 中未布置的感兴趣的题；3、补充设计题见后。
⼆、算法设计、程序与运⾏结果编写⼀个程序algo2-5.cpp，实现循环双单链表的各种基本运算（假设循环双链表的元素类型为char），并在此基础上设计⼀个主程序完成如下功能：（1）初始化循环双链表h（2）⼀次采⽤尾插法插⼊a,b,c,d,e元素（3）输出循环双链表h（4）输出循环双链表h的长度（5）判断循环双链表h是否为空（6）输出循环双链表h的第三个元素（7）输出元素a的位置（8）在第4个元素位置上插⼊f元素（9）输出循环双链表h（10）删除L的第3个元素（11）输出循环双链表h（12）释放循环双链表h2、算法设计(1) 设计思路⾸先我们应该写出所有的关于循环双链表的最基本的运算函数，完成个如下功能，⽐如初始化，释放，判断是否为空，计算链表元素个数，输出链表，取得第i个位置的值，插⼊和删除第i个元素等功能，然后在主函数中调⽤这些函数即可。
基于改进KMP算法的字符文件子串查找
数据结构实验报告知识范畴：字符串完成日期：2017年4月14日实验题目：基于改进KMP算法的字符文件子串查找实验内容及要求：从键盘输入字符文件名以及子串，用改进KMP算法在字符文件中实现子串查找。
要求程序输出子串的改进nextval数组元素值以及子串在文件中成功匹配的次数（查找失败输出成功匹配次数为0）。
实验目的：掌握子串查找的KMP算法。
数据结构设计简要描述：序言：这是本学期第四个实验，本实验是要求我们将一个文件中的字符串读取出来，并自己从键盘上输入一个字符串来进行匹配，并用kmp算法来进行字符串的匹配查找；数据结构简单设计：本实验主要可分为三大模块，第一，从文件中读取出主串，并将其保存在一个字符数组中；第二，通过我们从键盘上输入的字符串来获得改进的nextval数组，而在改进的nextval数组求值算法中，变量还是跟踪的是next数组的值；第三，利用kmp算法来进行主串（char *s）和模式子串（char *t）的匹配，并求出成功匹配的次数；算法设计简要描述：1,求nextval数组的值，我们将不需要用到next数组就可以直接求出nextval数组的值，使nextval得出示值为-1，即nextval[0] = k = -1;将子串下标j初始化为1，然后通过t[j]和t[k]的值变化来获得nextval数组的值，其中的要点是，k值跟踪的仍然是未改进的next[j]的值；2，利用kmp算法来进行主串和模式子串的匹配，定义一个记录匹配的变量c = 0，主串下标为 i= 0，子串下标j = 0，当主串和子串第一个元素匹配成功后，进行i++和j++操作，都遍历到下一个元素；当进行一次成功匹配时，将子串的下标回溯到初始位置，记录变量c++，此时主串下标已经到达匹配成功的下一个元素，再继续进行匹配，知道主串到达末尾，结束匹配。
输入/输出设计简要描述：1，输入：输入存储主串的文件名，输入子串；2，输出：当输入文件名后，会打印输出主串；当输入子串后，会打印输出nextval数组的值以及匹配成功的次数值c。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构
实
验
报
告
学院软件学院
年级2009级
班级班
学号
姓名
2010 年 3 月24 日
目录
一、实验内容 (1)
二、实验过程 (X)
三、实验结果 (X)
一、实验内容：
1、实验题目：KMP算法
2、实验要求：实现教材中字串比较kmp算法，比较模式串abaabcac与主串acabaabaabcacaabc。
3、实验目标：了解并掌握串的类型定义和基本操作，并在此基础上实现kmp算法。
了解kmp算法的基本原理和next函数的使用。
二、实验过程：
1、任务分配
2、设计思想
（1）KMP算法：在模式匹配中，每当一趟匹配过程出现字符比较不等时，不需要回溯i指针，而是利用已经得到的“部分匹配”的结果将模式向右滑动尽可能远的一段距离之后，继续进行比较。
（2）next函数：看成一个模式匹配问题，整个模式串既是主串又是模式串，可仿照KMP算法。
3、需求分析
(1) 输入的形式和输入值的范围：输入主串S,模式串T，位置pos
(2) 输出的形式：模式串在主串中开始匹配的位置i
(3) 程序所能达到的功能：利用kmp算法完成模式串和主串的模式匹
配，并输出模式串在主串中开始匹配的位置
(4) 测试数据：
S=acabaabaabcacaabc
T=abaabcac
Pos=6
4、概要设计
1).抽象数据类型
Class String()定义字符串
Int StrLength()返回串的长度
V oid get_next()求模式串T的next函数值并存入next
int kmp()利用模式串T的next函数求出T在主串S中第pos个字符之后的位置的KMP算法
2).算法
a.kmp算法模块：实现主串和模式串的模式匹配
b.next函数模块：实现模式串自身的模式匹配，并存入nxet函数中
c.接收处理命令（初始化数据）
5、详细设计
程序代码（含注释）
6、调试分析
（1）调试中的问题分析：
a.
（2）算法的时空分析：
在利用简单的Index()函数进行模式匹配时，虽然易于理解，但是该算法效率很低。
在某些特殊情况下，因为在主串中可能存在多个和模式串“部分匹配”的子串，因而引起指针i的多次回溯，从而导致时间复杂度过高。
对于kmp算法，每当一趟匹配过程中出现字符比较不等时，不需要回溯i指针，而是利用已经得到的“部分匹配”的结果将模式向右滑动尽可能远的一段距离之后，继续进行比较。
因此kmp算法的效率较高，时间复杂度也较低。
7、测试结果
列出你的测试结果，包括输入和输出。
这里的测试数据应该完整和严格，最好多于需求分析中所列。
8、说明（如果有）
三、实验结果：（结果分析，心得体会等）
1.结果分析
kmp算法的实验，既体现了字符串的定义原理和基本特点，又通过对字符串模式匹配实验的练习，得到了一种效率更高、时间复杂度更低的kmp算法
2.心得体会：这次kmp算法代码的编写给了我深刻的体会，它不仅让我了解了字符串的基本操作和相关知识点。
也通过字符串模式匹配实验的练习，让我学习了一种更为高效、时间复杂度更低的kmp算法。
注：共三大项，具体每一项的内容可根据自己的报告内容分条叙述，自行安排得当即可。
备注：（正文采用宋体小四，间距20磅）
以上说明仅供参考。
实验报告从这5部分展开，具体内容可自由发挥。
如有雷同，均按零分处理。