数据结构实验报告《三、串及其应用》

合集下载

数据结构3-串及其应用.

数据结构3-串及其应用.

实验3:串及其应用一、实验目的掌握串类型的实现方法和文本模式匹配方法,熟悉一般文字处理软件的设计方法。

二、问题描述全屏幕文本编辑器通过终端对文本文件进行创建、插入、删除、修改、存储等操作。

用户可完成对文本的插入、删除、修改等功能。

三、实验要求1、对光标实现如下操作:上、下、左、右移动一个字符位置;向前、后翻页;光标移至文件首、尾;光标移至本行首、尾。

2、实现基本编辑命令:I----在当前光标前插入内容,按ESC结束F----在当前光标后插入内容,按ESC结束D----删除光标所在行ND---删除光标位置开始的n行N-----删除光标上的字符W----将修改后的文本保存下来Q----退出编辑状态。

四、实验环境PC微机DOS操作系统或Windows 操作系统Turbo C 程序集成环境或Visual C++ 程序集成环境五、实验步骤1、在内存开辟可容纳80行大小的编辑工作区和buffer 的修改缓冲区。

2、要求用户输入编辑文件名,对读入的文件建立相应的页表和行表,在文本编辑程序中设立页指针、行指针、字符指针,分别指示当前操作的页、行、字符。

3、执行插入、删除、修改操作时,将本次操作内容放到缓冲区;4、操作确定后,将修改后的文本存到文件中。

六、测试数据自行设定。

七、实验报告要求实验报告应包括以下几个部分:1、问题描述;2、算法的设计描述;3、测试结果的分析与讨论。

4、设计与实现过程中的体会,进一步的改进设想。

5、实验总结。

八、思考题1、对命令格式非法等错误做严格检查和适当处理。

2、扩充编辑操作,如对某行进行串替换?。

数据结构串的基本操作及应用实验报告

数据结构串的基本操作及应用实验报告

实验日期2010.5.10 教师签字成绩实验报告【实验名称】第四章串的基本操作及应用【实验目的】1、熟悉将算法转换成程序代码的过程。

2、了解串的逻辑结构特性,熟练掌握串顺序存储结构的C 语言描述方法。

3、熟练掌握串的基本操作:求长度、串的连接、插入、删除等,掌握串的存取特性。

【实验原理】1.串可以可以有三种存储方式,分别为顺序存储、堆分配存储、链式存储,串的基本操作在这三种存储方式下操作。

2.串的模式匹配KMP算法在每一趟匹配过程中出现字符不等时,不需回溯指针,而是利用已经得到的部分匹配结果的结果将模式向右滑动尽可能远的一段距离,继续进行比较。

【实验内容】1.串的顺序存储表示及基本操作(插入、删除、求串长、合并连接串、求子串、串比较等)#include<stdio.h>#include<iostream.h>#include<malloc.h>#include<string.h>#define SIZE 20struct HString{char ch[SIZE];int length;};void StrInsert(HString &s,int pos,HString t){int i,j;if(pos<1||pos>s.length+1)cout<<"ERROR!";if(t.length){for(i=s.length-1;i>=pos-1;--i)s.ch[i+t.length]=s.ch[i];for(j=0;j<=t.length-1;j++)s.ch[pos-1+j]=t.ch[j];s.length+=t.length;}}void StrDelete(HString &s,int pos,int len){int i;int v=pos-1;if(pos<1||pos>s.length||len<0||len>s.length-pos+1)cout<<"ERROR!";for(i=pos+len-1;i<=s.length-1;i++)s.ch[v++]=s.ch[i];s.length-=len;}void StrAssign(HString &t,char chars[]){int i;char *c;for(i=0,c=chars;*c;++i,++c);if(!i){t.length=0;}else{for(int j=0;j<i;j++)t.ch[j]=chars[j];t.length=i;}}int StrLen(HString &s){return s.length;}int StrCompare(HString &s,HString t){for(int i=0;i<s.length&&i<t.length;i++){if(s.ch[i]!=t.ch[i])return (int)(t.ch[i]-s.ch[i]);}return s.length-t.length;}void Concat(HString &t,HString s1,HString s2){int i=s1.length+s2.length;for(i=0;i<s1.length;i++)t.ch[i]=s1.ch[i];t.length=s1.length+s2.length;for(i=s1.length;i<t.length;i++)t.ch[i]=s2.ch[i-s1.length];}int SubString(HString &sub,HString s,int pos,int len) {if(pos<1||pos>s.length||len<0||len>s.length-pos+1) {cout<<"ERROR!"<<endl;return 0;}if(!len){sub.length=0;}else{int i=len;for(i=0;i<len;i++)sub.ch[i]=s.ch[pos+i-1];sub.length=len;}}void Display(HString &t){for(int i=0;i<=t.length-1;i++)cout<<t.ch[i];cout<<endl;}void main(){int i;char s[20];do{cout<<"选择您要进行的串的基本操作:"<<endl;cout<<"1.插入"<<endl<<"2.删除"<<endl<<"3.串连结"<<endl<<"4.取子串"<<endl<<"5.串比较"<<endl<<"6.求串长"<<endl<<"7.结束"<<endl;cin>>i;switch(i){case 1:{HString s,t;int pos;cout<<"请输入串s:";cin>>s.ch;StrAssign(s,s.ch);cout<<endl;cout<<"请输入要插入的串t:";cin>>t.ch;StrAssign(t,t.ch);cout<<endl;cout<<"请输入你所要插入的位置:";cin>>pos;StrInsert(s,pos,t);cout<<"插入之后串变为:";Display(s);break;}case 2:{HString s;int pos,len;cout<<"请输入串s:";cin>>s.ch;StrAssign(s,s.ch);cout<<"请输入你所要删除串的首位置为:";cin>>pos;cout<<"请输入你需要删除的串的长度:";cin>>len;StrDelete(s,pos,len);cout<<"删除之后串变为:";Display(s);break;}case 3:{HString s1,s2,t;cout<<"请输入串s1:";cin>>s1.ch;StrAssign(s1,s1.ch);cout<<"请输入串s2:";cin>>s2.ch;StrAssign(s2,s2.ch);Concat(t,s1,s2);cout<<"s1与s2合并后的串为:";Display(t);break;}case 4:{HString sub,s;int pos,len;cout<<"请输入主串s:";cin>>s.ch;StrAssign(s,s.ch);cout<<"请输入所取原串的起始位置pos:";cin>>pos;cout<<"请输入子串的长度len:";cin>>len;SubString(sub,s,pos,len);cout<<"取出的子串为:";Display(sub);break;}case 5:{HString s,t;int value;cout<<"请输入串s:";cin>>s.ch;StrAssign(s,s.ch);cout<<"请输入串t:";cin>>t.ch;StrAssign(t,t.ch);value=StrCompare(s,t);if(value>0) cout<<"串s大于串t"<<endl;else if(value==0) cout<<"串s等于串t"<<endl;else cout<<"串s小于串t"<<endl;cout<<endl;break;}case 6:HString s;char *chars;int val;cout<<"请输入串s:";cin>>s.ch;StrAssign(s,s.ch);val=StrLen(s);cout<<"串的长度为:"<<val<<endl;break;case 7:cout<<"操作结束!"<<endl;break;default:cout<<"输入错误!请重新输入!"<<endl;break;}}while(i!=7);}2.串的堆分配存储表示及基本操作(插入、删除、求串长、合并连接串、求子串、串比较等)#include<stdio.h>#include<iostream.h>#include<malloc.h>#include<string.h>struct HString{char *ch;int length;};void StrInsert(HString &s,int pos,HString t){int i,j;if(pos<1||pos>s.length+1)cout<<"ERROR!";if(t.length){s.ch=(char*)realloc(s.ch,(s.length+t.length)*sizeof(char));for(i=s.length-1;i>=pos-1;--i)s.ch[i+t.length]=s.ch[i];for(j=0;j<=t.length-1;j++)s.ch[pos-1+j]=t.ch[j];s.length+=t.length;}}void StrDelete(HString &s,int pos,int len){int i;int v=pos-1;if(pos<1||pos>s.length||len<0||len>s.length-pos+1)cout<<"ERROR!";for(i=pos+len-1;i<=s.length-1;i++)s.ch[v++]=s.ch[i];s.length-=len;}void StrAssign(HString &t,char *chars){int i;char *c;for(i=0,c=chars;*c;++i,++c);if(!i){t.ch=NULL;t.length=0;}else{t.ch=(char *)malloc(i*sizeof(char));for(int j=0;j<i;j++)t.ch[j]=chars[j];t.length=i;}}int StrLen(HString &s){return s.length;}int StrCompare(HString &s,HString t){for(int i=0;i<s.length&&i<t.length;i++){if(s.ch[i]!=t.ch[i])return (int)(t.ch[i]-s.ch[i]);}return s.length-t.length;}void Concat(HString &t,HString s1,HString s2){int i=s1.length+s2.length;t.ch=(char *)malloc(i*sizeof(char));for(i=0;i<s1.length;i++)t.ch[i]=s1.ch[i];t.length=s1.length+s2.length;for(i=s1.length;i<t.length;i++)t.ch[i]=s2.ch[i-s1.length];}int SubString(HString &sub,HString s,int pos,int len){if(pos<1||pos>s.length||len<0||len>s.length-pos+1){cout<<"ERROR!"<<endl;return 0;}if(!len){sub.ch=NULL;sub.length=0;}else{int i=len;sub.ch=(char *)malloc(i*sizeof(char));for(i=0;i<len;i++)sub.ch[i]=s.ch[pos+i-1];sub.length=len;}}void Display(HString &t){for(int i=0;i<=t.length-1;i++)cout<<t.ch[i];cout<<endl;}void main(){int i;char s[20];cout<<"选择您要进行的串的基本操作:"<<endl;do{cout<<"1.插入"<<endl<<"2.删除"<<endl<<"3.串连结"<<endl<<"4.取子串"<<endl<<"5.串比较"<<endl<<"6.求串长"<<endl<<"7.结束"<<endl;cin>>i;switch(i){case 1:{HString s,t;char a[20],b[20];char *sa,*sb;int pos;cout<<"请输入串s:";cin>>a;sa=a;StrAssign(s,sa);cout<<endl;cout<<"请输入要插入的串t:";cin>>b;sb=b;StrAssign(t,sb);cout<<endl;cout<<"请输入你所要插入的位置:";cin>>pos;StrInsert(s,pos,t);cout<<"插入之后串变为:";Display(s);break;}case 2:{HString s;char str[20];char *chars;int pos,len;cout<<"请输入串s:";cin>>str;chars=str;StrAssign(s,chars);cout<<"请输入你所要删除串的首位置为:";cin>>pos;cout<<endl;cout<<"请输入你需要删除的串的长度:";cin>>len;cout<<endl;StrDelete(s,pos,len);cout<<"删除之后串变为:";Display(s);break;}case 3:{HString s1,s2,t;char a[20],b[20];char *sa,*sb;cout<<"请输入串s1:";cin>>a;sa=a;StrAssign(s1,sa);cout<<"请输入串s2:";cin>>b;sb=b;StrAssign(s2,sb);Concat(t,s1,s2);cout<<"s1与s2合并后:";Display(t);break;}case 4:{HString sub,s;char a[20];char *sa;int pos,len;cout<<"请输入主串s:";cin>>a;sa=a;StrAssign(s,sa);cout<<"请输入所取原串的起始位置pos:";cin>>pos;cout<<"请输入子串的长度len:";cin>>len;SubString(sub,s,pos,len);cout<<"该子串为:";Display(sub);break;}case 5:{HString s,t;int value;char a[20],b[20];char *sa,*sb;cout<<"请输入串s:";cin>>a;sa=a;StrAssign(s,sa);cout<<"请输入串t:";cin>>b;sb=b;StrAssign(t,sb);value=StrCompare(s,t);if(value>0) cout<<"串s大于串t"<<endl;else if(value==0) cout<<"串s等于串t"<<endl;else cout<<"串s小于串t"<<endl;cout<<endl;break;}case 6:HString s;char str[20];char *chars;int val;cout<<"请输入串s:";cin>>str;chars=str;StrAssign(s,chars);val=StrLen(s);cout<<"串的长度为:"<<val<<endl;break;case 7:cout<<"操作结束!"<<endl;break;default:cout<<"输入错误!请重新输入!"<<endl;break;}}while(i!=7);3.KMP算法的C实现#include<iostream.h>#include<malloc.h>#include<string.h>struct HString{char *ch;int length;};void StrAssign(HString &t,char *chars){int i;char *c;for(i=0,c=chars;*c;++i,++c);if(!i){t.ch=NULL;t.length=0;}else{t.ch=(char *)malloc(i*sizeof(char));for(int j=0;j<i;j++)t.ch[j]=chars[j];t.length=i;}}void get_next(HString s,int next[]){int i,j;i=1;j=0;next[1]=0;while(i<s.length){if(j==0||s.ch[i-1]==s.ch[j-1]){i++;j++;next[i]=j;}else j=next[j];}for(i=1;next[i]!='\0';i++)cout<<next[i]<<" ";}int Index(HString s,HString t,int pos){int i=pos;int j=1;int next[20];get_next(t,next);while(i<=s.length&&j<=t.length){if(s.ch[i-1]==t.ch[j-1]||j==0){ ++i;++j;}else{j=next[j];}}if(j>t.length)return i-t.length;else return 0;}void Display(HString t){for(int i=0;i<t.length;i++)cout<<t.ch[i];cout<<endl;}void main(){ HString s,t;int pos,k;char a[20],b[20];char *sa,*sb;cout<<"请输入主串s:";cin>>a;sa=a;StrAssign(s,sa);cout<<"请输入模式串t:";cin>>b;sb=b;StrAssign(t,sb);cout<<"请输入起始位置pos:";cin>>pos;k=Index(s,t,pos);if(k==0)cout<<"匹配失败!"<<endl<<endl;else{cout<<"从第"<<k<<"个位置开始匹配"<<endl;Display(s);for(int i=1;i<k;i++)cout<<" ";Display(t);}}【小结讨论】1. 此程序关键在于位置查询,由于对C语言函数的陌生导致问题变的繁琐,自己的C语言水平有待提高。

数据结构实验报告串

数据结构实验报告串

数据结构实验报告串《数据结构实验报告串》在数据结构课程中,实验报告是非常重要的一环。

通过实验报告,我们能够将课堂上学到的知识应用到实际中,加深对数据结构的理解和掌握。

本次实验报告串将介绍我们在数据结构实验中所进行的一系列实验,以及实验结果和分析。

实验一:数组和链表的比较在第一个实验中,我们对数组和链表进行了比较。

我们通过编写代码,分别实现了数组和链表的基本操作,包括插入、删除、查找等。

通过对比实验结果,我们发现在插入和删除操作中,链表的效率明显高于数组,而在查找操作中,数组的效率更高。

这说明在不同的场景下,数组和链表都有各自的优势和劣势。

实验二:栈和队列的应用在第二个实验中,我们学习了栈和队列的应用。

我们通过编写代码,实现了栈和队列的基本操作,并应用到实际问题中。

我们发现栈适合用于实现逆波兰表达式和括号匹配等问题,而队列适合用于实现广度优先搜索和模拟排队等问题。

这些实际应用让我们更加深入地理解了栈和队列的特点和用途。

实验三:树和图的遍历在第三个实验中,我们学习了树和图的遍历算法。

我们通过编写代码,实现了深度优先搜索和广度优先搜索算法,并应用到树和图的遍历中。

我们发现深度优先搜索适合用于解决迷宫问题和拓扑排序等问题,而广度优先搜索适合用于解决最短路径和连通性问题。

这些实验让我们更加深入地理解了树和图的遍历算法,以及它们在实际中的应用。

通过以上一系列实验,我们对数据结构的理论知识有了更深入的理解,同时也掌握了一些实际应用的技能。

实验报告串的编写过程也让我们更加熟练地掌握了数据结构的相关操作和算法。

希望通过这些实验,我们能够更好地应用数据结构知识,解决实际中的问题,提高编程能力和算法水平。

数据结构实验报告串

数据结构实验报告串

一、实验目的1. 理解串的概念和性质;2. 掌握串的基本操作,如连接、赋值、求长度、定位等;3. 熟悉串的两种存储结构:顺序存储和链式存储;4. 能够实现串的简单应用,如字符串匹配、子串查找等。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 串的定义和性质2. 串的顺序存储结构3. 串的链式存储结构4. 串的基本操作5. 字符串匹配算法6. 子串查找算法四、实验步骤1. 定义串的数据结构```cpp#define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int length;} StrString;```2. 实现串的基本操作```cpp// 初始化串void InitString(StrString &S) {S.length = 0;}// 赋值操作void AssignString(StrString &S, StrString T) { for (int i = 0; i < T.length; i++) {S.data[i] = T.data[i];}S.length = T.length;}// 求长度操作int Length(StrString S) {return S.length;}// 定位操作int Index(StrString S, StrString T, int pos) { int i, j;i = pos;for (j = 0; j < T.length && i < S.length; j++, i++) { if (S.data[i] != T.data[j]) {i = i - j;j = 0;}}if (j == T.length) {return i - T.length + 1;}return 0;}```3. 实现字符串匹配算法```cpp// 字符串匹配算法(KMP算法)int KMPMatch(StrString S, StrString T) {int i, j;int next[T.length];// 构建next数组for (i = 1, j = 0; i < T.length; i++) {while (j > 0 && T.data[i] != T.data[j]) {j = next[j - 1];}if (T.data[i] == T.data[j]) {j++;}next[i] = j;}// 匹配过程i = 0;j = 0;while (i < S.length && j < T.length) { if (S.data[i] == T.data[j]) {i++;j++;} else if (j > 0) {j = next[j - 1];} else {i++;}}if (j == T.length) {return i - j;}return 0;}```4. 实现子串查找算法```cpp// 子串查找算法(朴素算法)int SubStringMatch(StrString S, StrString T) {int i, j;for (i = 0; i <= S.length - T.length; i++) {j = 0;while (j < T.length && S.data[i + j] == T.data[j]) {j++;}if (j == T.length) {return i;}}return 0;}```五、实验结果与分析1. 初始化串、赋值操作、求长度操作、定位操作均能正常执行,符合预期。

实验三 串基本操作的编程实现

实验三 串基本操作的编程实现

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY Array
数据结构
实验三串基本操作的编程实现
【实验目的】
内容:串基本操作的编程实现
要求:
串基本操作的编程实现(2学时,验证型),掌握串的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、合并、剪裁等操作,存储结构可以在顺序结构或链接结构、索引结构中任选,也可以全部实现。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】
验证性实验(学时数:2H)
【实验内容】
字符串长度计算,字符串的连接,字符串的替换,求子串等。

【注意事项】
1.开发语言:使用C。

2.可以自己增加其他功能。

【实验分析、说明过程】
【思考问题】
【实验小结】 (总结本次实验的重难点及心得、体会、收获)。

串-数据结构实验报告

串-数据结构实验报告

串-数据结构实验报告串数据结构实验报告一、实验目的本次实验的主要目的是深入理解和掌握串这种数据结构的基本概念、存储方式以及相关的操作算法。

通过实际编程实现串的基本操作,提高对数据结构的理解和编程能力,培养解决实际问题的思维和方法。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

三、实验原理(一)串的定义串是由零个或多个字符组成的有限序列。

在本次实验中,我们主要关注的是字符串。

(二)串的存储方式1、顺序存储定长顺序存储:使用固定长度的数组来存储字符串,长度不足时用特定字符填充。

堆分配存储:根据字符串的实际长度动态分配存储空间。

2、链式存储每个节点存储一个字符,并通过指针链接起来。

(三)串的基本操作1、串的创建和初始化2、串的赋值3、串的连接4、串的比较5、求子串6、串的插入和删除四、实验内容及步骤(一)顺序存储方式下串的实现1、定义一个结构体来表示顺序存储的字符串,包含字符数组和字符串的实际长度。

```cppstruct SeqString {char str;int length;};```2、实现串的创建和初始化函数```cppSeqString createSeqString(const char initStr) {int len = strlen(initStr);SeqString s;sstr = new charlen + 1;strcpy(sstr, initStr);slength = len;return s;}```3、串的赋值函数```cppvoid assignSeqString(SeqString& s, const char newStr) {delete sstr;int len = strlen(newStr);sstr = new charlen + 1;strcpy(sstr, newStr);slength = len;}```4、串的连接函数```cppSeqString concatSeqString(const SeqString& s1, const SeqString& s2) {SeqString result;resultlength = s1length + s2length;resultstr = new charresultlength + 1;strcpy(resultstr, s1str);strcat(resultstr, s2str);return result;}```5、串的比较函数```cppint compareSeqString(const SeqString& s1, const SeqString& s2) {return strcmp(s1str, s2str);}```6、求子串函数```cppSeqString subSeqString(const SeqString& s, int start, int len) {SeqString sub;sublength = len;substr = new charlen + 1;strncpy(substr, sstr + start, len);substrlen ='\0';return sub;}```7、串的插入函数```cppvoid insertSeqString(SeqString& s, int pos, const SeqString& insertStr) {int newLength = slength + insertStrlength;char newStr = new charnewLength + 1;strncpy(newStr, sstr, pos);strcpy(newStr + pos, insertStrstr);strcpy(newStr + pos + insertStrlength, sstr + pos);delete sstr;sstr = newStr;slength = newLength;}```8、串的删除函数```cppvoid deleteSeqString(SeqString& s, int start, int len) {int newLength = slength len;char newStr = new charnewLength + 1;strncpy(newStr, sstr, start);strcpy(newStr + start, sstr + start + len);delete sstr;sstr = newStr;slength = newLength;}```(二)链式存储方式下串的实现1、定义一个节点结构体```cppstruct LinkNode {char data;LinkNode next;LinkNode(char c) : data(c), next(NULL) {}};```2、定义一个链式存储的字符串类```cppclass LinkString {private:LinkNode head;int length;public:LinkString(const char initStr);~LinkString();void assign(const char newStr);LinkString concat(const LinkString& other);int compare(const LinkString& other);LinkString subString(int start, int len);void insert(int pos, const LinkString& insertStr);void deleteSub(int start, int len);};```3、实现各个函数```cppLinkString::LinkString(const char initStr) {length = strlen(initStr);head = NULL;LinkNode p = NULL;for (int i = 0; i < length; i++){LinkNode newNode = new LinkNode(initStri);if (head == NULL) {head = newNode;p = head;} else {p>next = newNode;p = p>next;}}}LinkString::~LinkString(){LinkNode p = head;while (p) {LinkNode temp = p;p = p>next;delete temp;}}void LinkString::assign(const char newStr) {//先释放原有的链表LinkNode p = head;while (p) {LinkNode temp = p;p = p>next;delete temp;}length = strlen(newStr);head = NULL;p = NULL;for (int i = 0; i < length; i++){LinkNode newNode = new LinkNode(newStri);if (head == NULL) {head = newNode;p = head;} else {p>next = newNode;p = p>next;}}}LinkString LinkString::concat(const LinkString& other) {LinkString result;LinkNode p1 = head;LinkNode p2 = otherhead;LinkNode p = NULL;while (p1) {LinkNode newNode = new LinkNode(p1->data);if (resulthead == NULL) {resulthead = newNode;p = resulthead;} else {p>next = newNode;p = p>next;}p1 = p1->next;}while (p2) {LinkNode newNode = new LinkNode(p2->data);if (resulthead == NULL) {resulthead = newNode;p = resulthead;} else {p>next = newNode;p = p>next;}p2 = p2->next;}resultlength = length + otherlength;return result;}int LinkString::compare(const LinkString& other) {LinkNode p1 = head;LinkNode p2 = otherhead;while (p1 && p2 && p1->data == p2->data) {p1 = p1->next;p2 = p2->next;}if (p1 == NULL && p2 == NULL) {return 0;} else if (p1 == NULL) {return -1;} else if (p2 == NULL) {return 1;} else {return p1->data p2->data;}}LinkString LinkString::subString(int start, int len) {LinkString sub;LinkNode p = head;for (int i = 0; i < start; i++){p = p>next;}for (int i = 0; i < len; i++){LinkNode newNode = new LinkNode(p>data);if (subhead == NULL) {subhead = newNode;} else {LinkNode temp = subhead;while (temp>next) {temp = temp>next;}temp>next = newNode;}p = p>next;}sublength = len;return sub;}void LinkString::insert(int pos, const LinkString& insertStr) {LinkNode p = head;for (int i = 0; i < pos 1; i++){p = p>next;}LinkNode insertHead = insertStrhead;while (insertHead) {LinkNode newNode = new LinkNode(insertHead>data);newNode>next = p>next;p>next = newNode;p = p>next;insertHead = insertHead>next;}length += insertStrlength;}void LinkString::deleteSub(int start, int len) {LinkNode p = head;for (int i = 0; i < start 1; i++){p = p>next;}LinkNode temp = p>next;for (int i = 0; i < len; i++){LinkNode delNode = temp;temp = temp>next;delete delNode;}p>next = temp;length = len;}```(三)测试用例1、顺序存储方式的测试```cppint main(){SeqString s1 = createSeqString("Hello");SeqString s2 = createSeqString("World");SeqString s3 = concatSeqString(s1, s2);std::cout <<"连接后的字符串: "<< s3str << std::endl; int cmpResult = compareSeqString(s1, s2);if (cmpResult < 0) {std::cout <<"s1 小于 s2" << std::endl;} else if (cmpResult == 0) {std::cout <<"s1 等于 s2" << std::endl;} else {std::cout <<"s1 大于 s2" << std::endl;}SeqString sub = subSeqString(s1, 1, 3);std::cout <<"子串: "<< substr << std::endl; insertSeqString(s1, 2, s2);std::cout <<"插入后的字符串: "<< s1str << std::endl; deleteSeqString(s1, 3, 2);std::cout <<"删除后的字符串: "<< s1str << std::endl; return 0;}```2、链式存储方式的测试```cppint main(){LinkString ls1("Hello");LinkString ls2("World");LinkString ls3 = ls1concat(ls2);std::cout <<"连接后的字符串: ";LinkNode p = ls3head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;int cmpResult = ls1compare(ls2);if (cmpResult < 0) {std::cout <<"ls1 小于 ls2" << std::endl;} else if (cmpResult == 0) {std::cout <<"ls1 等于 ls2" << std::endl;} else {std::cout <<"ls1 大于 ls2" << std::endl;}LinkString sub = ls1subString(1, 3);std::cout <<"子串: ";p = subhead;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;ls1insert(2, ls2);std::cout <<"插入后的字符串: ";p = ls1head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;ls1deleteSub(3, 2);std::cout <<"删除后的字符串: ";p = ls1head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;return 0;}```五、实验结果及分析(一)顺序存储方式1、连接操作成功实现,输出了正确连接后的字符串。

数据结构串实验报告

数据结构串实验报告

数据结构串实验报告实验报告课程数据结构实验名称实验三串学号姓名实验日期:实验三串实验目的:1. 熟悉串类型的实现方法,了解简单文字处理的设计方法;2. 熟悉C语言的字符和把字符串处理的原理和方法;3. 熟悉并掌握模式匹配算法。

实验原理:顺序存储结构下的关于字符串操作的基本算法。

模式匹配算法BF、KMP实验内容:4-19. 在4.4.3节例4-6的基础上,编写比较Brute-Force算法和KMP算法比较次数的程序。

4-20. 设串采用静态数组存储结构,编写函数实现串的替换Replace(S,start,T,V),即要求在主串S中,从位置start开始查找是否存在字串T。

若主串S中存在子串T,则用子串V替换子串T,且函数返回1;若主串S中不存在子串T,则函数返回0;并要求设计I am a student”,T=“student”,V=“teacher”。

主函数进行测试。

一个测试例子为:S=“程序代码:4-19的代码:/*静态存储结构*/typedef struct{char str[MaxSize];int length;}String;/*初始化操作*/void Initiate(String *S) {S->length=0;}/*插入子串操作 */int Insert(String *S, int pos, String T)/*在串S的pos位置插入子串T*/{int i;if(pos<0||pos>S->length){printf("The parameter pos is error!\n");return 0;}else if(S->length+T.length>MaxSize){printf("The space of the array is not enough!\n"); return 0;}else{for(i=S->length-1; i>=pos; i--)S->str[i+T.length]=S->str[i];/*依次后移数据元素*/for(i=0; i<T.length; i++)S->str[pos+i]=T.str[i]; /*插入*/S->length=S->length+T.length;/*产生新的串长度值*/return 1;}}/*删除子串操作 */int Delete(String *S, int pos, int len) /*删除串S的从pos位置开始长度为len的子串值*/{int i;if(S->length<=0){printf("No elements deleting!\n");return 0;}else if(pos<0||len<0||pos+len>S->length){printf("The parameters pos and len are not correct!\n"); return 0;}else{for(i=pos+len; i<=S->length-1; i++)S->str[i-len]=S->str[i];/*依次前移数据元素*/S->length=S->length-len;/*产生新的串长度值*/return 1;}}/*取子串操作 */int SubString(String S, int pos, int len, String *T)/*取串S的从pos位置开始长度为len的子串值赋给子串T*/ {int i;if(pos<0||len<0||pos+len>S.length){printf("The parameters pos and len are not correct!\n"); return 0;}else{for(i=0; i<=len; i++)T->str[i]=S.str[pos+i]; /*给子串T赋值*/T->length=len; /*给子串T的长度域赋值*/return 1;}}/*查找子串BF(Brute-Force)操作*/int BFIndex(String S, int start, String T)/*查找主串S从start开始的子串T,找到返回T在S中的开始字符下标,否则返回-1*/ {int i= start, j=0, v;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else{i=i-j+1;j=0;}}if(j==T.length)v=i-T.length;elsev=-1;return v;}/*查找子串KMP(D.E.Knuth-J.H.Morris-V.R.Pratt)操作 */ int KMPIndex(String S, int start, String T, int next[])/*查找主串S从start开始的子串T,找到返回T在S中的首字符下标,*/ /*否则返回-1*//*数组Next中存放有模式串T的next[j]值*/{int i= start, j=0, v;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else if(j==0) i++;else j=next[j];}if(j==T.length)v=i-T.length;elsev=-1;return v;}/*求模式串next[j]值的操作 */void GetNext(String T, int next[])/*求子串T的next[j]值并存放于数组next中*/ {int j=1, k=0;next[0]=-1;next[1]=0;while(j<T.length){if(T.str[j]=T.str[k]){next[j+1]=k+1;j++;k++;}else if(k==0){next[j+1]=0;j++;}else k=next[k];}}/*查找子串BF(Brute-Force)算法累计次数 */int BFIndexC(String S, int start, String T)/*查找主串S从start开始的子串T,找到返回T在S中的开始字符下标,否则返回-1*/{int i= start, j=0, t=0;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else{i=i-j+1;j=0;}t++;}return t;}/*查找子串KMP(D.E.Knuth-J.H.Morris-V.R.Pratt)操作 */ int KMPIndexC(String S, int start, String T, int next[])/*查找主串S从start开始的子串T,找到返回T在S中的首字符下标,*/ /*否则返回-1*//*数组Next中存放有模式串T的next[j]值*/{int i= start, j=0, t=0;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else if(j==0)i++;else j=next[j];t++;}return t;}测试主函数:#include<stdio.h>#define MaxSize 100#include"SString.h"#include"BFandKMP.h"void main(void){String S={{"cddcdc"},6}, T={{"abcde"},5};String S1={{"aaaaaaaa"},8}, T1={{"aaaab"},5};String S2={{"aaaaaaaaaaaaaaaaad"},18}, T2={{"aaaab"},5};int next[20], count;count=BFIndexC(S,0,T);printf("从S中查找T的Brute-Force算法比较次数:%d\n",count); GetNext(T, next);count=KMPIndexC(S,0,T,next);printf("从S中查找T的KMP算法比较次数:%d\n",count);count=BFIndexC(S1,0,T1);printf("从S1中查找T1的Brute-Force算法比较次数:%d\n",count); GetNext(T1, next);count=KMPIndexC(S1,0,T1,next);printf("从S1中查找T1的KMP算法比较次数:%d\n",count);count=BFIndexC(S2,0,T2);printf("从S2中查找T2的Brute-Force算法比较次数:%d\n",count); GetNext(T2, next);count=KMPIndexC(S2,0,T2,next);printf("从S2中查找T2的KMP算法比较次数:%d\n",count);}4-20的部分代码:Replace函数:/* 从主串S中查找字串T,若存在,并用串V替换串T并返回1,否则,返回0*/ int Replace(String S,int start,String T,String V){int i,v;Initiate(&S);Initiate(&T);Initiate(&V);for(i=0; i<strlen(S.str); i++)S.length=S.length+1;for(i=0; i<strlen(T.str); i++)T.length=T.length+1;for(i=0; i<strlen(V.str); i++)V.length=V.length+1;i=BFIndex(S, 0, T);if (i!=-1){if(Delete(&S, i, T.length))Insert(&S, i, V);for(i=0; i<S.length; i++)printf("%c", S.str[i]);printf("\n");return v=1;}else{printf("主串S中不存在串T\n");return v=0;}}测试主函数:#define MaxSize 80#include<stdio.h>#include<string.h>#include "SString.h"int main(void){ int v;String S={"I am a student."}, T={"student"}, V={"teacher"}; v=Replace(S,0,T,V);printf("返回%d\n",v);}实验结果:4-19.程序调式结果:4-20.程序调式结果:总结与思考KMP算法的比较次数比Brute-Force算法的少。

串的数据结构实验报告

串的数据结构实验报告

串的数据结构实验报告
《串的数据结构实验报告》
在计算机科学领域,数据结构是非常重要的基础知识之一。

而串(String)作为一种基本的数据结构,在实际应用中也扮演着重要的角色。

本实验报告将介绍串的数据结构以及在实验中的应用和表现。

首先,串是由零个或多个字符组成的有限序列,是一种线性表。

在计算机中,串通常用来表示文本数据,比如字符串、文件名等。

在实际应用中,串的操作非常频繁,比如查找、替换、插入、删除等。

因此,对串的数据结构进行深入的研究和实验是非常有意义的。

在本次实验中,我们选择了C语言作为实验的编程语言,使用指针和动态内存分配来实现串的数据结构。

我们首先定义了一个结构体来表示串,结构体中包括串的长度和字符数组指针。

然后,我们实现了一系列操作函数,比如串的初始化、销毁、拷贝、连接、比较等。

通过这些操作函数,我们可以对串进行各种操作,从而验证串的数据结构的有效性和实用性。

在实验过程中,我们发现串的数据结构在实际应用中表现出了很好的性能和灵活性。

比如,在进行串的连接操作时,我们可以直接使用指针进行操作,而不需要额外的内存开销。

在进行串的比较操作时,我们可以逐个字符进行比较,从而实现高效的比较操作。

这些实验结果表明,串的数据结构在实际应用中具有很高的实用价值。

总的来说,本次实验对串的数据结构进行了深入的研究和实验,验证了串的数据结构在实际应用中的有效性和实用性。

通过本次实验,我们对串的数据结构有了更深入的理解,也为以后的实际应用提供了参考和借鉴。

希望本次实验报
告能对读者有所帮助,也希望能够对串的数据结构进行更深入的研究和探索。

数据结构串实验报告

数据结构串实验报告

数据结构串实验报告数据结构串实验报告引言:数据结构是计算机科学中的重要概念之一,它研究如何组织和存储数据,以便能够高效地访问和操作。

串是一种特殊的数据结构,它由一系列字符组成,可以用来表示文本、字符串等信息。

本实验旨在通过实现串的基本操作,深入理解数据结构的原理和应用。

一、实验目的本实验的主要目的是掌握串的基本操作,包括串的初始化、插入、删除、查找等。

通过实际编程实现这些操作,可以加深对数据结构的理解,并提高编程能力。

二、实验环境本实验使用C语言进行编程,需要在计算机上安装相应的开发环境,如GCC编译器等。

三、实验内容1. 串的初始化串的初始化是指将一个空串创建出来,并为其分配内存空间。

在实验中,可以使用字符数组来表示串,并通过赋值操作将空串初始化。

2. 串的插入串的插入是指在指定位置插入一个或多个字符。

在实验中,可以通过遍历数组,将插入位置之后的字符依次后移,然后将待插入的字符放入指定位置。

3. 串的删除串的删除是指删除指定位置的一个或多个字符。

在实验中,可以通过遍历数组,将删除位置之后的字符依次前移,覆盖待删除的字符。

4. 串的查找串的查找是指在串中查找指定字符或子串,并返回其位置。

在实验中,可以通过遍历数组,逐个比较字符或子串,找到匹配的位置。

五、实验步骤1. 初始化串首先,创建一个字符数组,并将其初始化为空串。

2. 插入字符在指定位置插入一个字符,可以通过遍历数组,将插入位置之后的字符依次后移,然后将待插入的字符放入指定位置。

3. 删除字符删除指定位置的一个字符,可以通过遍历数组,将删除位置之后的字符依次前移,覆盖待删除的字符。

4. 查找字符在串中查找指定字符,可以通过遍历数组,逐个比较字符,找到匹配的位置。

六、实验结果经过实验,我们成功实现了串的初始化、插入、删除和查找等基本操作。

通过不断调试和优化,我们的程序能够高效地处理大量的字符操作,具有较好的性能和稳定性。

七、实验总结通过本次实验,我们深入理解了数据结构中串的原理和应用。

串及其应用实验实验原理

串及其应用实验实验原理

串及其应用实验实验原理串是计算机科学中的一种数据结构,它由一系列字符组成,字符之间按照一定的顺序排列。

串可以用来表示文本、数字、符号等各种类型的数据。

在计算机中,串是非常常见的数据类型,它广泛应用于字符串处理、文本搜索、密码学等领域。

在实验中,串经常被用来进行数据的传输和通信。

串通常由一个或多个字节组成,每个字节由8个二进制位表示。

在串通信中,数据是按照一定的协议和规则进行传输的。

串口是一种常见的串通信接口,它通常用于计算机与外部设备之间的数据传输。

串的实验原理主要涉及串通信的基本原理和相关的实验技术。

在串通信中,数据是按照比特流的形式传输的。

发送端将数据按照一定的格式编码后发送,接收端接收到数据后进行解码。

在串通信中,还要考虑数据的同步和错误检测。

为了确保数据的可靠传输,通常会在串通信中加入一些错误检测和纠正的机制,如奇偶校验、循环冗余校验等。

串的实验应用非常广泛,下面我们将介绍几个典型的串应用实验。

第一个应用是串口通信实验。

串口通信是计算机与外部设备之间进行数据交换的一种常见方式。

通过串口通信,计算机可以与各种外部设备进行数据的发送和接收。

串口通信实验可以帮助我们了解串口通信的原理和操作方法,掌握串口通信的编程技术。

第二个应用是串口调试实验。

串口调试是在开发和调试嵌入式系统时经常用到的一种技术。

通过串口调试,我们可以实时地查看和调试嵌入式系统的运行状态,方便我们进行故障排查和性能优化。

串口调试实验可以帮助我们熟悉串口调试的工具和方法,提高嵌入式系统的开发和调试效率。

第三个应用是串口通信模块的设计与实现实验。

串口通信模块是一种硬件电路,它可以实现计算机与外部设备之间的串口通信。

通过串口通信模块的设计与实现实验,我们可以了解串口通信模块的工作原理,掌握串口通信模块的设计方法和实现技术。

第四个应用是串口通信的性能测试实验。

性能测试是评估串口通信性能的一种方法。

通过性能测试实验,我们可以测试串口通信的数据传输速度、传输稳定性和传输可靠性等性能指标。

数据结构实验报告《三、串及其应用》

数据结构实验报告《三、串及其应用》

数据结构实验报告《三、串及其应用》时间:20XX年X月X日数据结构实验报告- - - - 串及其应用之文学研究助手【问题描述】文学研究人员需要统计某篇英文小说中某些单词(特别是形容词)的出现次数和位置,甚至连数字和标点符号的个数也可以统计。

试写一个实现这一目标的文字统计系统,称为“文学研究助手”。

【基本要求】1、输入一页文字,静态存储一页文章,每行最多不超过80个字符,共N行;2、分别统计出其中英文字母数、空格数、标点符号及整篇文章总字数;3、统计某一字符串在文章中出现的次数,并输出该次数;4、删除某一子串,并将后面的字符前移。

【运用拓展】1、保存输入文章到本地text文本中;2、模式匹配基于KMP算法;3、仿真友好界面显示:(1)、要求用菜单选择操作,分别用几个子函数实现相应的功能;(2)、输入数据的形式和范围:可以输入大写、小写的英文字母、任何数字及标点符号。

(3)、输出形式:1)、分行输出用户输入的各行字符;2)、分5行输出“全部字母数“、“数字个数“、“空格个数“、“标点符号个数”“文章总字数“;3)、输出删除某一字符串后的文章。

【涉及的知识点】链串的插入,删除,查找,模式匹配(knp算法)及文件的写入与写出,用switch,case语句进行菜单的选择,用while 语句进行循环,用if语句进行条件的判断等等。

【设计思路】、总体思路:本文采用链式存储字符串,链串的插入采用后插法,以‘#’ 为字符串结束的标志。

在插入字符串的同时用文件存储字符串。

、删除算法的基本思路:输入要删除的字符串,同样以‘#’结束,然后在文中查找该字符串,若找到了则把它删除,同时长度要减少;否则,没找到不能删除。

查找算法与删除算法类似;但也有不同之处,不同在于:这里是要查找某字符串在文中出现的次数,因此,当找到该字符串后还要继续往后查找,并将次数加1;直到文章的末尾才结束查找。

、用菜单做选择:用switch,case语句进行选择判断,并用类的对象调用类的成员函数以实现特定的功能。

串的数据结构实验报告

串的数据结构实验报告

串的数据结构实验报告串的数据结构实验报告一、引言在计算机科学中,串(String)是一种基本的数据结构,用于存储和操作字符序列。

串的数据结构在实际应用中具有广泛的用途,例如文本处理、搜索引擎、数据库等。

本实验旨在通过实践掌握串的基本操作和应用。

二、实验目的1. 理解串的概念和基本操作;2. 掌握串的存储结构和实现方式;3. 熟悉串的常见应用场景。

三、实验内容1. 串的定义和基本操作在本实验中,我们采用顺序存储结构来表示串。

顺序存储结构通过一个字符数组来存储串的字符序列,并使用一个整型变量来记录串的长度。

基本操作包括:- 初始化串- 求串的长度- 求子串- 串的连接- 串的比较2. 串的模式匹配串的模式匹配是串的一个重要应用场景。

在实验中,我们将实现朴素的模式匹配算法和KMP算法,并比较它们的性能差异。

四、实验步骤1. 串的定义和基本操作首先,我们定义一个结构体来表示串,并实现初始化串、求串的长度、求子串、串的连接和串的比较等基本操作。

2. 串的模式匹配a. 实现朴素的模式匹配算法朴素的模式匹配算法是一种简单但效率较低的算法。

它通过逐个比较主串和模式串的字符来确定是否匹配。

b. 实现KMP算法KMP算法是一种高效的模式匹配算法。

它通过利用已匹配字符的信息,避免不必要的比较,从而提高匹配效率。

3. 性能比较与分析对比朴素的模式匹配算法和KMP算法的性能差异,分析其时间复杂度和空间复杂度,并讨论适用场景。

五、实验结果与讨论1. 串的基本操作经过测试,我们成功实现了初始化串、求串的长度、求子串、串的连接和串的比较等基本操作,并验证了它们的正确性和效率。

2. 串的模式匹配我们对两种模式匹配算法进行了性能测试,并记录了它们的运行时间和内存占用情况。

结果表明,KMP算法相较于朴素算法,在大规模文本匹配任务中具有明显的优势。

六、实验总结通过本实验,我们深入学习了串的数据结构和基本操作,并掌握了串的模式匹配算法。

串及其应用的实验报告

串及其应用的实验报告

一、实验目的1. 理解串的概念及其基本操作。

2. 掌握串的创建、插入、删除、查找等操作。

3. 学习串在具体应用场景中的应用。

二、实验原理串(String)是一种特殊的线性表,它是由若干字符构成的有限序列。

串的基本操作包括创建、插入、删除、查找等。

在计算机科学中,串广泛应用于文本处理、字符串匹配、自然语言处理等领域。

三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验内容1. 串的创建2. 串的插入3. 串的删除4. 串的查找5. 串在文本处理中的应用五、实验步骤1. 串的创建(1)定义串的结构体```cppstruct String {char data; // 指向串中字符的指针int length; // 串的长度};```(2)创建串```cppString createString(const char str) {String s;s.data = new char[strlen(str) + 1]; // 为串分配内存strcpy(s.data, str); // 复制字符串到串中s.length = strlen(str); // 设置串的长度return s;}```2. 串的插入(1)在串的指定位置插入字符```cppvoid insertChar(String& s, int position, char ch) {if (position < 0 || position > s.length) {return; // 插入位置不合法}char newData = new char[s.length + 2]; // 为新串分配内存 strcpy(newData, s.data); // 复制原串到新串newData[position] = ch; // 在指定位置插入字符strcpy(s.data, newData); // 复制新串到原串s.length++; // 更新串的长度}```(2)在串的指定位置插入子串```cppvoid insertSubstring(String& s, int position, const char subStr) {if (position < 0 || position > s.length) {return; // 插入位置不合法}char newData = new char[s.length + strlen(subStr) + 1]; // 为新串分配内存strcpy(newData, s.data); // 复制原串到新串strcpy(newData + position, subStr); // 在指定位置插入子串strcpy(s.data, newData); // 复制新串到原串s.length += strlen(subStr); // 更新串的长度}```3. 串的删除(1)删除串中的单个字符```cppvoid deleteChar(String& s, int position) {if (position < 0 || position >= s.length) {return; // 删除位置不合法}char newData = new char[s.length]; // 为新串分配内存strcpy(newData, s.data); // 复制原串到新串strcpy(newData + position, newData + position + 1); // 删除指定位置的字符strcpy(s.data, newData); // 复制新串到原串s.length--; // 更新串的长度}```(2)删除串中的子串```cppvoid deleteSubstring(String& s, const char subStr) {int position = s.indexOf(subStr); // 查找子串的位置if (position == -1) {return; // 子串不存在}deleteChar(s, position); // 删除子串}```4. 串的查找(1)查找串中的单个字符```cppint indexOfChar(const String& s, char ch) {for (int i = 0; i < s.length; i++) {if (s.data[i] == ch) {return i; // 找到字符,返回位置}}return -1; // 未找到字符,返回-1}```(2)查找串中的子串```cppint indexOfSubstring(const String& s, const char subStr) {for (int i = 0; i <= s.length - strlen(subStr); i++) {if (strncmp(s.data + i, subStr, strlen(subStr)) == 0) {return i; // 找到子串,返回位置}}return -1; // 未找到子串,返回-1}```5. 串在文本处理中的应用(1)字符串替换```cppvoid replaceSubstring(String& s, const char oldStr, const char newStr) { int position = indexOfSubstring(s, oldStr);while (position != -1) {deleteSubstring(s, oldStr); // 删除旧子串insertSubstring(s, position, newStr); // 插入新子串position = indexOfSubstring(s, oldStr); // 继续查找旧子串}}```(2)字符串排序```cppvoid sortString(String& s) {char temp = new char[s.length + 1];strcpy(temp, s.data);qsort(temp, s.length, sizeof(char), [](const void a, const void b) { return (const char)a - (const char)b;});strcpy(s.data, temp);delete[] temp;}```六、实验结果与分析1. 创建串:通过创建一个包含“Hello, World!”的串,验证了串的创建功能。

串-数据结构实验报告[修改版]

串-数据结构实验报告[修改版]

第一篇:串-数据结构实验报告【源程序】:#include #include #include void choose(char *s, int i,int m,char *t);//i位置截取m个字符函数void main() //主函数{ char *s,*t; int i,sl,m;s=(char *)malloc(100*sizeof(char));t=(char *)malloc(100*sizeof(char));printf("\n 输入主字符串s=?"); gets(s); printf("\n s=%s\n",s);printf("\n 输入位置i=?"); scanf("%d",&i); printf("\n i=%d\n",i);printf("\n 输入字符个数m=?"); scanf("%d",&m); printf("\n m=%d\n",m);sl=strlen(s);if(i>sl) printf("i位置出错\n");else if(i+m>sl+1) printf("m位置出错\n");else{choose(s,i,m,t);printf("\n 子串为t=%s\n",t);} } //end_main void choose(char *s, int i,int m,char *t) { int n;int j=0; for(n=i;n三.实验结论及分析串的存储结构包含有顺序存储结构和链式存储结构。

在串的顺序存储结构中,表示串的长度通常有两种方法:一种方法是设置一个串的长度参数,其优点在于便于在算法中用长度参数控制循环过程;另一种方法是在串值得末尾添加结束标记,此种方法的优点在于便于系统自动实现。

串及其应用的实验报告

串及其应用的实验报告

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

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

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

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

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

(2)向串中添加字符,观察串的变化。

(3)使用串的长度函数,计算串的长度。

(4)使用串的比较函数,比较两个串的大小。

(5)使用串的连接函数,将两个串连接起来。

(6)使用串的截取函数,截取指定位置和长度的子串。

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

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

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

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

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

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

(2)创建一个主串和一个模式串。

(3)使用模式匹配算法,在主串中查找模式串的位置。

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

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

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

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

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

(3)实现文本搜索和替换功能。

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

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

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

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

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

3串及其应用

3串及其应用

#include<stdio.h>#define MAX 255typedef struct{char data[MAX];int length;}string;string strassing(){string S;scanf("%s",&S);return (S);}int strcompare(string S,string T){ int i;for(i=0,i<S.length&&i<T.length;++i;)if(S.data[i]!=T.data[i]) return S.data[i]- T.data[i];return S.length-T.length;}int strlength(string S){int i;i=0;S.length=0;while(S.data[i]!='\0'){S.length++;i++;}return (S.length);}void concat(string S1,string T){int i,j,k,len1,len2;string S;i=0; j=0;k=0;len1=strlength(S1);len2=strlength(T);if(len1+len2>MAX)printf("ERROR\n");else{while(S1.data[j]!='\0'){S.data[i]=S1.data[j];i++;j++;}while(T.data[k]!='\0'){S.data[i]=T.data[k];i++;k++;}S.data[i]='\0';printf(" the new string:");printf("%s",S.data);}}void substring(string S1,int i,int len){string S;int j;int slen;slen=strlength(S1);if(i<1||i>slen||len<0||len>slen-i+1){ printf("ERROR");}else{ for(j=0;j<len;j++)S.data[j]=S1.data[i+j-1];S.data[j]='\0';printf("the substring is:%s",S.data); }}char menu(void){ char ch; clrscr(); printf("\n\n");printf(" MENU \n");printf(" ===========================\n");printf(" operations\n");printf(" 1.strassing \n");printf(" 2.strcompare \n");printf(" 3.strlength \n");printf(" 4.concat\n");printf(" 5.substring\n");printf(" 0. exit \n");printf(" ===========================\n");printf(" Choice(0,1,2,3,4,5):");ch=getchar();return(ch);}main(){string S,S1,T;int i,len,k,flag=1;char ch;i=0;do{ ch=menu(); clrscr();switch (ch){case'1': printf("input string S1:");S1=strassing();printf("input string T:");T=strassing();getch();break;case'2':k=strcompare(S1,T);if(k>0)printf("string S1>string T.\n");else if(k==0)printf("string S1=string T.\n");elseprintf("string S1<string T.\n");getch();break;case'3':k=strlength(S1);printf("The length of the string S1 is:%d",k);getch();break;case'4':concat(S1,T);getch();break;case'5': printf("input the location and the length:");scanf("%d%d",&i,&len);substring(S1,i,len);getch();break;case'0': flag=0;}}while(flag==1);}。

实训报告总结数据结构(3篇)

实训报告总结数据结构(3篇)

第1篇一、实训背景随着计算机技术的飞速发展,数据结构作为计算机科学中的基础学科,已经成为计算机专业学生必须掌握的知识。

为了提高我们的编程能力和解决实际问题的能力,我们进行了为期一个月的数据结构实训。

本次实训旨在通过实际操作,加深对数据结构理论知识的理解,提高编程实践能力。

二、实训内容本次实训主要包括以下内容:1. 线性表2. 栈与队列3. 串4. 树与二叉树5. 图6. 查找技术7. 排序技术三、实训过程1. 线性表线性表是数据结构中最基本的数据结构之一,包括顺序表和链表两种形式。

实训过程中,我们首先学习了顺序表的基本操作,如插入、删除、查找等。

然后,我们通过实现链表,掌握了指针的运用,进一步理解了线性表的数据存储方式。

2. 栈与队列栈是一种后进先出(LIFO)的数据结构,队列是一种先进先出(FIFO)的数据结构。

实训中,我们实现了栈和队列的顺序存储和链式存储,并分别实现了入栈、出栈、入队、出队等基本操作。

3. 串串是由零个或多个字符组成的有限序列。

实训中,我们学习了串的基本操作,如连接、求子串、替换等。

通过实现串的操作,我们加深了对字符串处理的理解。

4. 树与二叉树树是一种层次结构,由节点组成。

实训中,我们学习了二叉树的遍历、查找、插入、删除等操作。

通过实现二叉树,我们掌握了树状数据结构的存储方式。

5. 图图是一种表示对象及其关系的数据结构。

实训中,我们学习了图的邻接矩阵和邻接表存储方式,并实现了图的遍历、最短路径等算法。

6. 查找技术查找技术是数据结构中的重要内容。

实训中,我们学习了顺序查找、二分查找、散列查找等查找算法,并通过实现这些算法,提高了查找效率。

7. 排序技术排序是将一组无序数据变为有序数据的过程。

实训中,我们学习了冒泡排序、选择排序、插入排序、快速排序等排序算法,并通过实现这些算法,提高了排序效率。

四、实训成果1. 理论知识方面:通过本次实训,我们对数据结构的基本概念、基本原理有了更加深入的理解。

《数据结构》实验三【 串的基本操作】

《数据结构》实验三【 串的基本操作】
for(n=0;n<i&&n<j;++n)
if(s[n]!=t[n])
{
m=t[n]-s[n];
printf(" %d\n",m);
break;
}
if(m==0)
{
m=i-j;
printf(" %d\n",m);
}
}
void Concat(char s[ ]) //串的连接
{
char t[MAXSTRLEN],l[MAXSTRLEN];
case 3: StrCompare(s);break;
case 4: Concat(s);break;
case 5:Index(s);brou want to continue?\n");
printf("------------- ");
do{
scanf("%c",&continue_or);
void PrintMenu( )//菜单函数输出显示
{
printf("*******************************************\n");
printf("******** 1.Copy existing string********\n");
printf("******** 2.String length********\n");
实验
类型
设计型
综合型
创新型








实验目的:
掌握串的结构以及基本操作。

数据结构串的应用及实现报告

数据结构串的应用及实现报告

实习报告课程名称: 数据结构实验名称: 串及其应用指导教师:学生班级:学生姓名:学生学号:完成日期:一、 需求分析1、本演示程序用C语言编写,实现串的堆分配存储基本操作、串的建立、串的输出、串的联接、求子串、串匹配、串的插入删除、串的替换等实现方法。

2、程序所达到的功能:(1) 建立串s=“abcdefghijklmn”,串s1=“xyz”,串t=“hijk”(2) 复制串t到t1,并输出t1的长度(3) 在串s的第9个字符位置插入串s1而产生串s2,并输出s2(4) 删除s第2个字符开始的5个字符而产生串s3,并输出s3(5) 将串s第2个字符开始的3个字符替换成串s1而产生串s4,并输出s4(6) 提取串s的第8个字符开始的4个字符而产生串s5,并输出s5(7) 将串s1和串t连接起来而产生串s6,并输出s6(8) 比较串s1和s5是否相等,输出结果二、 概要设计1、编写栈的基本操作函数链串类型定义如下所示:typedef struct snode{char data;struct snode *next;}listring;(1)串赋值 Assign(s,t)将一个字符串常量赋给串s,即生成一个其值等于t的串s(2)串复制 StrCopy(s,t)将串t赋给串s(3)计算串长度 StrLength(s)返回串s中字符个数(4)判断串相等StrEqual(s,t)若两个串s与t相等则返回1;否则返回0。

(5)串连接 Concat(s,t)返回由两个串s和t连接在一起形成的新串。

(6)求子串 SubStr(s,i,j)返回串s中从第i(1≤i≤StrLength(s))个字符开始的、由连续j个字符组成的子串。

(7)插入InsStr (s,i,t)将串t插入到串s的第i(1≤i≤StrLength(s)+1)个字符中,即将t的第一个字符作为s的第i个字符,并返回产生的新串(8)串删除 DelStr (s,i,j)从串s中删去从第i(1≤i≤StrLength(s))个字符开始的长度为j的子串,并返回产生的新串。

实验三 串类型及操作

实验三  串类型及操作

编程实现在串s中下标为pos的字符之前插入串t。串的存储 结构采用定长顺序存储,表示如下: /*串结构定义*/
#define MAXLEN 40
typedef struct {
char ch[MAXLEN]; int len;
}SString;
请完成函数int StrInsert(SString *s, int pos, SString t)的代码,若插入成功,函数值返回1, 则 返回0。
4、实验步骤
(1)理解串的类型定义及插入操作的基本实验原理;
(2)仔细分析实验内容,给出其算法和流程图; (3)用C或C++语言实现该算法; (4)给出测试数据,并分析其结果; (5)在实验报告册上写出实验过程。
课后作业


编写模式匹配算法。
基本思想:设有两个字符串s和t,首先将s1与t1进 行比较,直到s的某一个字符si和ti相同,再将它们 之后的字符进行比较,若也相同,则如此继续往下 比较,当s的某一个字符si与t的字符tj不同时,则s 返回到本趟开始字符的下一个字符,即si-j+2,t返 回到t1,继续开始下一趟的比较,重复上述过程。 若t中的字符全部比较完,则说明本趟匹配成功,本 趟的起始位置是i-j+1,否则,匹 struct seqstr {char string[max] ; int len : } ; int index ( struct seqstr *s ,struct seqstr * t ) { int I , j ; i=0 ; j=0 ; while ( i<s->len&&j<t->len ) if ( s->string[i] == t->string[j]) { i++ ; j++ ; } else { i=i-j+1 ; j=1; } if ( j>=t->len ) return( j-t->len) ; else return( -1) ;}
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
3)、输出删除某一字符串后的文章。
【涉及的知识点】
链串的插入,删除,查找,模式匹配(knp算法)及文件的写入与写出,用switch,case语句进行菜单的选择,用while语句进行循环,用if语句进行条件的判断等等。
【设计思路】
、总体思路:本文采用链式存储字符串,链串的插入采用后插法,以‘#’
为字符串结束的标志。在插入字符串的同时用文件存储字符串。
{
int num=0; //赋初值
int space=0;
int len=0;
int word=0;
int douhao=0;
int sentence=0;
ifstream in("cpp-home.txt"); //读入创建的txt文本文件
bunch *p;
p=head->next ;
while(p->next!=NULL) //不为空文件是扫描需要记录的信息
}
}
void *found(bunch *head,bunch *HEAD)
{
int num=0;
bunch *P,*Q,*R;
P=head->next ;
Q=HEAD->next ;
R=P;
while((P!=NULL)&&(Q!=NULL))
{
if(P->data==Q->data )
{
P=P->next ;
中南大学物理学院
数据结构实验报告- - - -
串及其应用之文学研究助手
专业班级:电信0903班
时间:2011年11月11日
数据结构实验报告- - - -
串及其应用之文学研究助手
【问题描述】
文学研究人员需要统计某篇英文小说中某些单词(特别是形容词)的出现次数和位置,甚至连数字和标点符号的个数也可以统计。试写一个实现这一目标的文字统计系统,称为“文学研究助手”。
cout<<"Go or not?('y'means yes,'n'means no),enter y or n."<<endl;
cin>>c;
while(c=='y'){
cout<<"请输入您的选择... ..."<<endl;
cin>>choice;
switch(choice)
{
case 1:
cout<<"新建文本:"<<endl;
、用菜单做选择:用switch,case语句进行选择判断,并用类的对象调用类的成员函数以实现特定的功能。由于采用链式存储字符串,它是按一个一个的字符进行存储的,当遇到空隔和换行符时它会忽略不计。为了解决这一问题,本文采用替换的方法——当要输入空格时就输入‘:’,当要输入换行符时就输入’\\’,在输出时,遇到‘:’就输出空格,遇到‘\\’就输出换行符。
ut<<endl; //换行输出所有统计信息
cout<<"总的字符数为:"<<len<<endl;
cout<<"空格数为:"<<space<<endl;
cout<<"逗号总数为:"<<douhao<<endl;
cout<<"单词数为:"<<word<<endl;
cout<<"句子总数为:"<<sentence<<endl;
if(p->data=='\\')//将双杠改为换行输出
{
cout<<'\n';
p=p->next ;
}//if"\\"
else //其他情况就记录字母
cout<<p->data;
p=p->next ;
}//while
word=word+1; //单词数自加1
sentence=sentence+1; //句子数自加1
4,void print2(link *head2)函数,输出要删除的字符串,其中,head2指向要删除的字符串的第一个字符。
5,void *found(link *head,link *head2)函数用于查找字符串在文中出现的次数;设置一个整型变量num,用于统计出现次数,其初始值为0。同样采用模式匹配的算法,但不同的是,找到第一次在文中出现的位置后num+1,并且还要继续找文中的下一个,找到了又要num+1,直到文章的末尾,然后输出num值。
{
cout<<"the word hav't found!"<<endl;
}
}
void PRINT(bunch *HEAD)
{ifstream in("home.text");
bunch *q;
q=HEAD->next ;
while(q!=NULL)
{
cout<<q->data ;
q=q->next ;
{
cout<<'?';
word++;
sentence++;
p=p->next ;
}//if“?”
if((p->data>=48)&&(p->data<=57))//当碰到的是数字0~9时记录
{
cout<<p->data ;
num++; //数字统计自加1
p=p->next ; //跳到下一位
}//if"0~9"
cout<<"*欢迎使用文本编辑器!*"<<endl;
cout<<"* *"<<endl;
cout<<"* 1:新建文本2:输出文本3:删除一串字符4查找单词出现的次数*"<<endl;
cout<<"********************************************************************************"<<endl;
cout<<"数字个数为:"<<num<<endl;
cout<<endl;
}
void deletel(bunch*head,bunch *HEAD) //删除操作
{
bunch *P,*Q,*R,*T;
T=head;
P=head->next;
Q=HEAD->next;
R=P;
while((P!=NULL)&&(Q!=NULL))//不为空时再进行删除操作
3、仿真友好界面显示:
(1)、要求用菜单选择操作,分别用几个子函数实现相应的功能;
(2)、输入数据的形式和范围:可以输入大写、小写的英文字母、任何数
字及标点符号。
(3)、输出形式:1)、分行输出用户输入的各行字符;
2)、分5行输出"全部字母数"、"数字个数"、"空格个
数"、“标点符号个数”"文章总字数";
、删除算法的基本思路:输入要删除的字符串,同样以‘#’结束,然后在文中查找该字符串,若找到了则把它删除,同时长度要减少;否则,没找到不能删除。
查找算法与删除算法类似;但也有不同之处,不同在于:这里是要查找某字符串在文中出现的次数,因此,当找到该字符串后还要继续往后查找,并将次数加1;直到文章的末尾才结束查找。
、部分函数模块流程图:
void *found(link *head,link *head2)
int num=0; link *P,*Q,*R; P=head->next ; Q=head2->next ; R=P;
While
(P!=NULL)&&(Q!=NULL)
if(P->data==Q->data )
{
len++; //长度先自加1
if(p->data==':')//将冒号改为空格输出
{
cout<<' ';
space++; //碰到空格号,空格数目自加1
word++; //字符数目自加1
p=p->next ; //移动到下一位循环扫描信息
}//if“:”
if(p->data ==',')//逗号的形式和空格一致,不赘述
else
cout<<"sorry,hav't found the word."<<endl;
return 0;
}
};
void main()
{int choice;
char c;
bunch *p,*q,*Y;
bunchlist a;
cout<<"********************************************************************************"<<endl;
相关文档
最新文档