串的基本操作
数据结构串的基本操作及应用实验报告
实验日期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语言水平有待提高。
算法与数据结构c语言版第4章串
详细描述
在C语言中，可以使用str_replace()函数来替换字符串 中的子串。该函数接受三个参数，第一个参数是源字 符串，第二个参数是要被替换的子串，第三个参数是 替换后的子串。str_replace()函数将源字符串中所有 出现的指定子串替换为新的子串，并返回替换后的新 字符串。需要注意的是，该函数不是标准C库中的函 数，需要引入额外的头文件或使用第三方库来实现。
char *tmp; // 临时变量，用 于临时存储替换过程中的字符串
片段
int len_rep; // 要被替换的子 串的长度
字符串的替换
int len_with; // 替换后的子串的长度
int count; // 替换次数（用于循环）
int len_front; // 前面的字符串长度 （每次替换前需要保留的部分）
字符串的连接
示例代码 ```c
char source1[] = "Hello, ";
字符串的连接
char source2[] = "world!"; char destination[20]; strcat(destination, source1);
字符串的连接
strcat(destination, source2); ```
字符串的比较
01
示例代码
02
```c
char str1[] = "Hello";
03
字符串的比较
1
char str2[] = "World";
2
int result = strcmp(str1, str2);
```
3
字符串的替换
数据结构顺序串基本操作实验报告
数据结构顺序串基本操作实验报告实验目的：1.掌握顺序串的定义和基本操作；2.掌握顺序串的插入、删除、查找等基本操作。
实验内容：实现顺序串的基本操作，包括串的初始化、插入、删除、查找、输出等操作，并通过实例测试验证操作的正确性。
实验原理：顺序串是一种以连续的存储空间来存储字符序列的数据结构。
在顺序串中，字符串的字符元素依次存储在一组连续的存储单元中，可以通过下标来访问和修改元素。
顺序串的基本操作包括初始化、插入、删除、查找等。
1.串的初始化：初始化一个空串，即将串的长度设置为0。
2.串的插入：在指定位置插入一个字符或字符串。
首先需要判断插入位置的合法性，即位置不能超过当前串的长度，并将插入位置后的元素后移一位，然后将要插入的元素放入指定位置。
3.串的删除：删除指定位置的字符或字符串。
首先需要判断删除位置的合法性，即位置不能超过当前串的长度，然后将删除位置后的元素前移一位。
4.串的查找：在串中查找指定字符或子串第一次出现的位置。
遍历串中的每个元素，检查是否与要查找的字符或子串相等，若相等则返回其位置。
5.串的输出：将串中的元素打印出来。
实验步骤：1.定义顺序串的数据结构。
使用数组来存储字符序列，并定义一个变量用于记录串的长度。
2.初始化一个空串。
将串的长度设置为0。
3.实现插入操作。
根据插入位置的合法性，判断是否需要进行插入操作。
如果插入位置超过了当前串的长度，则将元素插入到串末尾；否则，将插入位置后的元素后移一位，并将要插入的元素放入指定位置。
4.实现删除操作。
根据删除位置的合法性，判断是否需要进行删除操作。
如果删除位置超过了当前串的长度，则无需删除；否则，将删除位置后的元素前移一位。
5.实现查找操作。
遍历串中的每个元素，检查是否与要查找的字符或子串相等，若相等则返回其位置。
6.实现输出操作。
遍历串中的每个元素，将其打印出来。
7.构造测试实例，并进行验证。
实验结果：以插入、删除、查找等操作为例，构造测试实例进行验证：假设有一个空串，插入字符'A'到位置0：结果为"A"；在串的末尾插入字符'B'：结果为"AB"；在位置1插入字符'C'：结果为"ACB"；删除位置3的字符：结果为"AC"；查找字符'C'的位置：结果为1实验总结：本次实验主要是对顺序串的基本操作进行了实现和验证。
串的应用实验报告小结
串的应用实验报告小结实验目的：本实验旨在探索串的应用，并通过实际操作，加深对串的理解和应用能力。
实验原理：串是计算机中常用的数据类型，表示一个字符序列。
在实际应用中，串具有很强的灵活性和实用性，可以用于字符串的处理、文本处理、数据传输等场景。
串的基本操作包括串的定义、串的赋值、串的连接、串的比较、串的查找、串的替换等。
实验仪器和材料：编程环境：本实验使用Python编程语言进行实验操作。
实验过程中需要使用字符串处理相关的函数和方法。
实验步骤：1. 串的定义与赋值：首先介绍串的定义方法，并进行一些基本的赋值操作，包括直接赋值和通过输入获取串的赋值。
2. 串的连接：实现两个串的连接操作，了解串的拼接方式及其应用场景。
3. 串的比较：通过比较两个串的内容，了解串的比较操作及其返回值的含义。
4. 串的查找与替换：实现对串的查找和替换操作，掌握相关函数的用法并思考其实际应用。
实验结果：通过本次实验，我对串的相关操作有了更深入的了解。
掌握了串的基本定义、赋值、连接、比较、查找和替换等操作，并能够将其应用到实际问题中。
在实验过程中，我学会了如何利用串来处理文本数据，进行查找和替换操作，以及如何利用串的连接来构造更复杂的字符串。
这些知识和实践经验对我的编程能力和问题解决能力都有所提高。
实验总结：通过本次实验，我对串的基本概念和相关应用有了更深入的了解。
串作为计算机中重要的数据类型，在实际应用中有着广泛的应用场景，掌握了串的相关操作，将对我的日常编程工作和问题解决能力产生积极的影响。
串的处理能力将对字符串处理、文本处理、数据传输等方面有很大帮助。
结语：本次实验使我更加深入地理解了串的概念及其在实际应用中的作用。
通过在实验中动手操作，我对串的相关操作有了更深入的了解，相信这将对我的编程能力和问题解决能力有所提升。
我也意识到了串在计算机领域的重要性和广泛的应用前景，将积极应用串的相关知识到我的日常工作和学习中。
串的基本操作
串得基本操作一、实验目得、意义(１)理解串得堆分配存储结构。
(2)理解用它们表示时插入,生成串,联接串与求子串得算法。
(3)根据具体问题得需要,能够设计出相关算法。
二、实验内容及要求说明1:学生在上机实验时,需要自己设计出所涉及到得函数,同时设计多组输入数据并编写主程序分别调用这些函数,调试程序并对相应得输出作出分析;修改输入数据,预期输出并验证输出得结果,加深对有关算法得理解。
具体要求:定义串得堆分配存储,完成串得基本操作:插入,生成串,联接串,求子串等。
三、实验所涉及得知识点C语言算法、循环算法、串得堆分配存储结构、插入,生成串,联接串与求子串得算法。
四、实验结果及分析(所输入得数据及相应得运行结果,运行结果要有提示信息,运行结果采用截图方式给出。
)五、总结与体会(调试程序得心得与体会,若实验课上未完成调试,要认真找出错误并分析原因等。
)调试程序时,出现了许多错误、如:串得堆分配存储结构、串得联接等。
另外还有一些语法上得错误。
由于对所学知识点概念模糊,试验课上未能完成此次上机作业。
后来经过查阅教材,浏览网页等方式,才完成试验。
这次试验出现错误最重要得原因就就是对课本知识点理解不深刻以及编写代码时得粗心。
以后要都去练习、实践,以完善自己得不足。
六、程序清单(包含注释)#inｃlude 〈ｓｔｄio、h>＃inｃluｄe 〈maｌloｃ。
ｈ〉＃include ＜ｓtｄlib。
ｈ〉tｙpedｅf cｈａr Stａtus;int stｒlen(ｃhar ＊p)｛inｔi=0;while(＊ｐ＋+)ｉ++;ｒｅｔurn i;}tｙpedef ｓtｒuct{ﻩchar *ch;ﻩ// 若就是非空串,则按串长分配存储区,否则ch为ＮULＬiｎt lｅｎｇtｈ; ／/ 串长度｝HＳｔring;// 初始化(产生空串)字符串Tｖoid InitString(HＳtｒinｇ *T)｛(＊T)。
lengｔｈ＝0;ﻩ(＊Ｔ)、ｃh=NULL;}/／生成一个其值等于串常量chaｒｓ得串TＳtatus ＳtｒAsｓign(HSｔｒing *Ｔ, ｃhar *cｈars){ﻩint i,j;if((*T)。
串的基本操作
串的基本操作一、实验目的、意义（1）理解串的堆分配存储结构。
（2）理解用它们表示时插入，生成串，联接串与求子串的算法。
（3）根据具体问题的需要，能够设计出相关算法。
二、实验内容及要求说明1：学生在上机实验时，需要自己设计出所涉及到的函数，同时设计多组输入数据并编写主程序分别调用这些函数，调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
具体要求：定义串的堆分配存储，完成串的基本操作：插入，生成串，联接串，求子串等。
三、实验所涉及的知识点C语言算法、循环算法、串的堆分配存储结构、插入，生成串，联接串与求子串的算法。
四、实验结果及分析（所输入的数据及相应的运行结果，运行结果要有提示信息，运行结果采用截图方式给出。
）五、总结与体会（调试程序的心得与体会，若实验课上未完成调试，要认真找出错误并分析原因等。
）调试程序时，出现了许多错误。
如：串的堆分配存储结构、串的联接等。
另外还有一些语法上的错误。
由于对所学知识点概念模糊，试验课上未能完成此次上机作业。
后来经过查阅教材，浏览网页等方式，才完成试验。
这次试验出现错误最重要的原因就是对课本知识点理解不深刻以及编写代码时的粗心。
以后要都去练习、实践，以完善自己的不足。
六、程序清单(包含注释)#include <>#include <>#include <>typedef char Status;int strlen(char *p){int i=0;while(*p++)i++;return i;}typedef struct{char *ch; ength=0;(*T).ch=NULL;}h)free((*T).ch); h = NULL;(*T).length = 0;}else{h = (char*)malloc(i*sizeof(char)); h) h[j] = chars[j];(*T).length = i;}return 1;}h)free((*T).ch); h=(char*)malloc*sizeof(char)); h) h[i]=[i];(*T).length=;return 1;}h){free((*S).ch);(*S).ch=NULL;}(*S).length=0;return 1;}h)free((*T).ch); ength=+;(*T).ch=(char *)malloc((*T).length*sizeof(char)); h) exit(0);for(i=0;i<;i++) h[i]=[i];for(i=0;i<;i++) h[+i]=[i];return 1;}h)free((*Sub).ch); h=NULL;(*Sub).length=0;}else{ h=(char*)malloc(len*sizeof(char));if(!(*Sub).ch)exit(0);for(i=0;i<=len-1;i++)(*Sub).ch[i]=[pos-1+i];(*Sub).length=len;}return 1;}ength+1) h = (char*)realloc((*S).ch,((*S).length+*sizeof(char));if(!(*S).ch)exit(0);for(i=(*S).length-1;i>=pos-1;--i) h[i+]=(*S).ch[i];for(i=0;i<;i++)(*S).ch[pos-1+i]=[i]; ength+=;}return 1;}ength<pos+len-1)exit(0);for(i=pos-1;i<=(*S).length-len;i++)(*S).ch[i]=(*S).ch[i+len];(*S).length-=len;(*S).ch=(char*)realloc((*S).ch,(*S).length*sizeof(char));return 1;}// 用V替换主串S中出现的所有与T相等的不重叠的子串int Replace(HString *S,HString T,HString V){int i=1; // 从串S的第一个字符起查找串Tif(StrEmpty(T)) // T是空串return 0;do{i=Index(*S,T,i); // 结果i为从上一个i之后找到的子串T的位置if(i) // 串S中存在串T{StrDelete(S,i,StrLength(T)); // 删除该串TStrInsert(S,i,V); // 在原串T的位置插入串Vi+=StrLength(V); // 在插入的串V后面继续查找串T }}while(i);return 1;}void DestroyString(){// 堆分配类型的字符串无法销毁}// 输出T字符串void StrPrint(HString T){int i;for(i=0;i<;i++)printf("%c",[i]);printf("\n");}int main(){int i;char c,*p="God bye!",*q="God luck!";// HString类型必需初始化InitString(&t);InitString(&s);InitString(&r);StrAssign(&t,p);printf("串t为: ");StrPrint(t);printf("串长为%d 串空否%d(1:空 0:否)\n",StrLength(t),StrEmpty(t)); StrAssign(&s,q);printf("串s为: ");StrPrint(s);i=StrCompare(s,t);if(i<0)c='<';else if(i==0)c='=';elsec='>';printf("串s%c串t\n",c);Concat(&r,t,s);printf("串t联接串s产生的串r为: ");StrPrint(r);StrAssign(&s,"oo");printf("串s为: ");StrPrint(s);StrAssign(&t,"o");printf("串t为: ");StrPrint(t);Replace(&r,t,s);printf("把串r中和串t相同的子串用串s代替后，串r为:\n");StrPrint(r);ClearString(&s);printf("串s清空后，串长为%d 空否%d(1:空 0:否)\n",StrLength(s),StrEmpty(s));SubString(&s,r,6,4);printf("串s为从串r的第6个字符起的4个字符，长度为%d 串s为: ", ;StrPrint(s);StrCopy(&t,r);printf("复制串t为串r,串t为: ");StrPrint(t);StrInsert(&t,6,s);printf("在串t的第6个字符前插入串s后，串t为: ");StrDelete(&t,1,5);printf("从串t的第1个字符起删除5个字符后,串t为: ");StrPrint(t);printf("%d是从串t的第1个字符起，和串s相同的第1个子串的位置\n", Index(t,s,1));printf("%d是从串t的第2个字符起，和串s相同的第1个子串的位置\n", Index(t,s,2));system("pause");return 0;}。
第四章 串
4.2 串的存储结构
一、串的顺序存储结构
1. 类型定义
#define maxlen 100 typedef struct { char data[maxlen+1]; int len; }SeqString; data[maxlen]存放结束标志‘\0‟
2、顺序串的常用运算： （1）串连接 concat ( s, t) 把串 s 和 t 联接在一起，形成的新串。
4.2 串的存储结构
（3）子串的插入 insert(s, pos, t ) 在串 s 的第 pos 个字符之前插入串 t。
int insert(SeqString * s, int pos, SeqString * t ) { int i; if(t->len==0) { printf(“空串！\n”); return 0 ; } if(pos<1 || pos>s->len+1) {printf(“位置错！”)；return 0;} if(s->len+t->len>maxlen) {printf(“溢出！”)；return 0;} for(i=s->len; i>=pos-1; i--) s->data[i+ t->len]=s->data[i]; for(i=0;i<t->len;i++) s->data[pos-1+i]=t->data[i]; s->len = s->len+ t->len return 1; }
4.2 串的存储结构
（2）求子串 substring (s, pos, len) 求串s的第 pos 个字符起长度为 len 的子串。
数据结构 串基本操作代码
数据结构串基本操作代码欢迎阅读本文档，本文档为数据结构中串的基本操作代码提供详细说明。
本文档包括以下章节：串的定义、串的赋值、串的比较、串的连接、串的子串提取、串的插入、串的删除、串的替换和串的长度操作。
一、串的定义：串是由零个或多个字符组成的有限序列，也可称为字符串。
在计算机中，一个字符占据一个字节的存储空间，而串则根据字符的个数确定所需的存储空间。
二、串的赋值：1.将一个串赋值给另一个串，可以使用循环将每个字符逐个复制到目标串中。
示例代码：```cvoid StrAssign(String& dest, String source) {int i;for (i = 0; i < source.length; i++) {dest.ch[i] = source.ch[i];}dest.length = source.length;}```2.将一个字符赋值给串的某个位置，可以使用下标操作符来实现。
示例代码：```cvoid StrAssignChar(String& dest, char c, int pos) { dest.ch[pos] = c;if (pos >= dest.length) {dest.length = pos + 1;}}```三、串的比较：1.逐个字符比较两个串，如果出现不同字符，则根据字符的ASCII码大小进行比较。
示例代码：```cint StrCompare(String s1, String s2) {int i;for (i = 0; i < s1.length && i < s2.length; i++) {if (s1.ch[i] != s2.ch[i]) {return s1.ch[i] - s2.ch[i];}}return s1.length - s2.length;}```2.判断两个串是否相等，如果两个串长度相等且对应位置的字符也相等，则认为两个串相等。
【数据结构】【串】【课堂笔记】（含代码）
【数据结构】【串】【课堂笔记】（含代码）串串的基本概念串是由0个或者多个字符组成的有限序列记为：s="a11a2……a n"串与线性表的对⽐串的逻辑结构：和线性表极为相似区别：串的数据对象约定是字符集串的基本操作：和线性表有很⼤区别线性表的基本操作：以单个元素为操作对象串的基本操作：以串的整体为操作对象⼦串与主串⼦串由串中任意个连续的字符组成的⼦序列主串包含⼦串的串字符位置字符在序列中的序号（从1开始）⼦串位置⼦串的⾸字符在主串中的位置串的基本操作加⼯型串复制：将某个串复制给当前串串连接：将串S1和S2联接⽽成⼀个新串串替换：⽤⼦串x替换当前串中的⼦串y插⼊⼦串：将⼦串插到当前串中的某个位置删除⼦串：从当前串中删除指定⼦串⼤写转⼩写：将串中的⼤写字母转化为对应⼩写字符⼩写转⼤写：将串中的⼩写字母转化为对应⼤写字符串压缩：将当前串中⾸部和尾部的所有空格删除引⽤型判空：判断当前串是否为空串⽐较：判断当前串与指定串是否相等求串长：返回当前串的字符个数求⼦串：返回串的第i个字符开始的长达k个字符的⼦串⼦串定位：输出⼦串在当前串中⾸次出现的位置串的顺序储存与实现在串的顺序储存中，⼀般有三种⽅法表⽰串的长度（1）⽤⼀个变量来表⽰串的长度（2）在串尾储存⼀个特殊字符作为串的终结符（3）⽤数组的0号存在串的长度串的实现顺序储存结构的串可以⽤字符数组来存储字符数据串的初始化public calss string{private int maxSize =10;//串中字符数组的初始长度private char[] chars;//存储元素的数组对象private int length;//保存串的当前长度public string(){}public string(int n){}public void copy(string t){}public boolean isEmpty(){}public int compare(string t){}public int getLength(){}...//此处省略部分成员⽅法}getter and setterpublic class string {private int maxSize =10;//串中字符数组的初始长度private char[] chars;//存储元素的数组对象private int length;//保存串的当前长度public string(){}public string(int n){}public void copy(string t){}public boolean isEmpty(){return length <= 0;}public int compare(string t){return -1;}public int getLength(){return length;}public int getMaxSize() {return maxSize;}public void setMaxSize(int maxSize) {this.maxSize = maxSize;}public char[] getChars() {return chars;}public void setChars(char[] chars) {this.chars = chars;}public void setLength(int length) {this.length = length;}}功能完善import javax.xml.crypto.dsig.keyinfo.RetrievalMethod;public class string {private int maxSize =10;//串中字符数组的初始长度private char[] chars;//存储元素的数组对象private int length;//保存串的当前长度//串的初始化//构造⼀个空串public string(){}//构造⼀个能保存n个字符串的串public string(int n){}public void copy(string t){//将串t复制给当前串if(this.maxSize<t.maxSize){this.maxSize=t.maxSize;this.chars = new char[this.maxSize];}this.length=0;//初始化当前串的长度for(int i=0;i<t.getLength();i++){this.chars[i]=t.chars[i];this.length++;}}public boolean isEmpty(){return length <= 0;}/*** compare 串⽐较* @param t 字符型* @return int型 | 若当前串等于串t，则返回值0；若当前串⼤于串t，则返回1；若当前串⼩于于串t，则返回-1 * @author xrilang*/public int compare(string t){int i = 0;while(this.chars[i]==t.chars[i] && i < this.length && i<t.getLength()){i++;}//若当前串等于串t，则返回值0if(i==this.length && i==t.length) return 0;//若当前串⼤于串t，则返回1else if(i==t.getLength() && i < this.length) return 1;//若当前串⼩于于串t，则返回-1else return -1;}/*** concat 串联结* @param t 字符型* @author 萌狼蓝天*/public void concat(string t){if(this.maxSize<this.length+t.getLength()){//当前串容量不够，暂存到数组tempArrchar[] tempArr = new char[this.length];for(int i=0;i<this.length;i++){tempArr[i]=this.chars[i];}//重设maxSize，使串容量满⾜需求this.maxSize = this.length+t.getLength();this.chars=new char[this.maxSize];//恢复当前串的原始状态for(int i=0;i<tempArr.length;i++){this.chars[i]=tempArr[i];}}for(int i=0;i<t.length;i++){this.chars[this.length]=t.chars[i];this.length++;}}/*** subString 求⼦串* @param pos int型索引所求⼦串起始位置,不能为负数* @param len int型长度所求⼦串的长度* @return string型返回所求⼦串，如果不存在则返回null* @author 萌狼蓝天*/public string subString(int pos,int len){if(pos<0) return null;if(pos+len>=this.length) {//从位置pos开始不存在长度为len的⼦串 return null;}string temp = new string(len);for(int i=0;i<len;i++){temp.chars[i]=this.chars[pos+i];temp.length ++;}return temp;}public int getLength(){return length;}public int getMaxSize() {return maxSize;}public void setMaxSize(int maxSize) {this.maxSize = maxSize;}public char[] getChars() {return chars;}public void setChars(char[] chars) {this.chars = chars;}public void setLength(int length) {this.length = length;}}。
串及其应用的实验报告
一、实验目的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!”的串，验证了串的创建功能。
string类型的使用和基本操作
String类型是编程语言中表示文本的数据类型。
在Java中，String 类型用于表示字符串，可以进行一系列基本操作，包括：
1. 创建字符串：可以使用双引号创建字符串，例如：String str = "Hello, World!";
2. 连接字符串：可以使用加号操作符连接两个字符串，例如：String str1 = "Hello"; String str2 = "World"; String str3 = str1 + " " + str2; // 输出"Hello World"
3. 获取字符串长度：使用length()方法可以获取字符串的长度，例如：int len = str.length();
4. 获取指定位置字符：使用charAt()方法可以获取指定位置的字符，例如：char ch = str.charAt(0);
5. 字符串比较：使用equals()方法可以比较两个字符串是否相等，例如：boolean isEqual = str1.equals(str2);
6. 字符串大小写转换：使用toUpperCase()和toLowerCase()方法可以将字符串转换为大写或小写形式，例如：String upperStr = str.toUpperCase(); String lowerStr = str.toLowerCase();
7. 去除空白字符：使用trim()方法可以去除字符串开头和结尾的空白字符，例如：String trimStr = str.trim();
这些是String类型的基本操作，可以通过其他方法进行更多复杂的操作，如查找子串、替换子串、分割字符串等。
第4章 串
第四章串讲课提要【主要内容】1．串的有关概念及基本操作2．串的存储结构3．串操作应用举例【教学目标】1．掌握串的有关概念及基本运算2．熟悉串的存储结构3．熟悉串操作应用举例学习指导1．概念和术语•串（String）（或字符串）：是由零个或多个字符组成的有限序列。
一般记为s= “a1a2…an”(n≥0)其中，s是串的名，用双引号括起来的字符序列是串的值。
•串的长度：串中字符的个数n。
•子串和主串：串中任意个连续的字符组成的子序列称为该串的子串。
包含子串的串相应地称为主串。
•空串：不包含任何字符的串，表示为“Ф”。
•空格串：由一个或多个空格字符组成的串。
例如：“”。
2．串的基本操作（1）用串变量赋值assign(s,t)和用串常量赋值create(s,ss)（2）判等函数equal(s, t）（3）求长函数length(s)（4）连接函数concat(s,t)（5）求子串函数substring(s, pos , len)（6）定位函数index(s,t)（7）置换函数replace(s,t,v)（8）插入子串insert(s,pos,t)（9）删除子串delete(s,pos,k)（10）串的复制copy(s,t)【例3-1】已知字符串：a=“an apple”，b=“other hero”，c=“her”，求：（1）concat(substr(a,1,2),b)。
（2）replace(a,substr(a,5,1),c)。
（3）index(a,c)和index(b,c)。
解：（1）返回值为“another hero”，其中substr(a,1,2)的返回值为“an”。
（2）返回值为“an aherherle”，其中sub(a,5,1)的返回值为“p”。
（3）返回值分别为0和3。
3．串的顺序存储结构（顺序串）串的顺序存储方式类似于线性表的顺序存储方式，其存储结构用C语言描述为：typedef struct strnode {char data[maxlen];int len;}SeqString; //定义顺序串类型【例3-2】设定串采用顺序存储结构，写出对串s1和串s2比较大小的算法。
串的基本操作
1上机实训3：串的基本操作一、实训目的通过实训，掌握串的运算（赋值，比较，联结，插入子串，模式匹配……等）二、实验理论知识1)串的基本概念及其含义串( string)是由零个或多个字符组成的有限序列，一般记作:s='a1a2…an'(n≥0)，其中s为串的名字，用单引号括起来的字符序列为串的值；ai(1≤i≤n)可以是字母、数字或其它字符（取决于程序设计语言所使用的字符集）；n为串中字符的个数，称为串的长度。
2)串的存储表示及其实现●顺序存储可以用一组地址连续的存储单元依次存放串的各个字符，这是串的顺序存储结构，也称为顺序串●链式存储和线性表的链式存储结构相类似，也可采用链表方式存储串值。
串的这种链式存储结构简称为链串。
用链表存储字符串，每个结点需要有两个域：一个数据域（data）和一个指针域(Next)，其中数据域存放串中的字符，指针域存放后继结点的地址。
3)模式匹配问题三、实训案例与分析【实例1】串的存储与基本运算【实例分析】在本实例中练习计算字符串的长度、字符串的复制、字符串的比较、字符串的连接、字符串的插入等基本操作。
在设计时1)编写一个菜单函数，根据不同情况做（1-5）不同选择。
2)如果选择1，即要求计算输入字符串的长度。
3)如果选择2，完成字符串的复制。
4)如果选择3，完成字符串的比较。
5)如果选择4，完成两个字符串的连接。
6)如果选择5，字符串的插入。
【参考程序】#include <stdio.h>#define MAX 128typedef enum {fail,success} status;typedef enum {false,true} boolean;main(){ int strlen();void strass();boolean strcmp();status strcat( );status strins();int t,n,i;boolean b;status st;char s[MAX],s1[MAX],s2[MAX];printf("\n1. The length of string\n");printf(" 2. The assignment of string\n");printf(" 3. A string compare with another string:\n"); printf(" 4. A string connect with another string:\n"); printf(" 5. A string to be inserted into another string\n"); printf(" Please input a operation:");/*输入操作选项*/ scanf("%d",&t);switch(t){case 1:printf("please input a string:\n");getchar();gets(s);n=strlen(s);printf("the length is: %d",n);break;case 2:printf("please input the first string:\n");getchar();gets(s1);printf("please input the second string:\n");getchar();gets(s2);strass(s1,s2);break;case 3:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string: \n"); gets(s2);b=strcmp(s1,s2);if (b==true)printf("equal\n");elseprintf("not equal\n");break;case 4:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string:\n"); gets(s2);st=strcat(s1,s2);if(st==success)printf("answer is %s\n",s1);elseprintf("error!\n");break;case 5:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string:\n"); gets(s2);printf("please input i:");scanf("%d",&i);st=strins(s1,i,s2);if(st==success)printf("answer is: %s\n",s1);else printf("error!\n");break;case 0:break;default: printf("There isn't this operation!");}}int strlen(s) /*求字符串的长度子函数*/char s[];{ int i;for(i=0;s[i]!='\0';i++);return (i);}void strass(s1,s2)char s1[],s2[];{ int i=0;while(s1[i]!='\0'){ s2[i]=s1[i];i++;}s2[i]='\0';printf("s2 is %s",s2);}boolean strcmp(s1,s2) /*字符串比较子函数*/ char s1[],s2[];{ int i=0;while (s1[i]==s2[i] && s1[i]!='\0' && s2[i]!='\0') i++;if (s1[i]=='\0' && s2[i]=='\0')return (true);elsereturn (false);}status strcat (s1,s2) /*字符串连接子函数*/char s1[],s2[];{ int i,j,k;i=strlen(s1);j=strlen(s2);if((i+j)>=MAXN)return(fail);for(k=0;k<=j;k++)s1[i+k]=s2[k];return (success);}status strins (s1,i,s2)char s1[],s2[];int i;{ int m,n,k;m=strlen(s1);n=strlen(s2);if (i<0||i>m||(m+n)>MAXN )return (fail) ;for(k=m;k>=i;k--)s1[k+n]=s1[k];for(k=0;k<n;k++)s1[i+k]=s2[k];return (success);}【测试数据与结果：】计算字符串的长度1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:1please input a string:you are a boy!the length is: 14字符串的复制1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:2please input the first string:you are a boy!please input the second string:i am a girl!s2 is you are a boy!字符串的比较1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:3please input the first string:you are a boy!please input the second string:i am a girl!not equal字符串的连接1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another stringPlease input a opertation:4please input the first string:you are a boy!please input the second string:i am a girl!answer is：you are a boy!i am a girl!字符串的插入1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another stringPlease input a opertation:5please input the first string:you are a boy!please input the second string:i am a girl!please input i:2answer is i am a girl! you are a boy!【实例2】统计主串指定单词在主串中出现的次数和位置【实例描述】统计主串指定单词在主串中出现的次数和位置，要求：1)输入以回车作为结束符的一串字符作为主串；2)求主串中指定单词出现的次数和位置，注意单词与子串的区别；【实例分析】假设num存放出现次数，初始化为0，position[i]存放每一次匹配时的位置。
第四章 串教案
第四章串★本章主要讲授内容1、串的定义和基本操作2、串的顺序存储结构3、串的链式存储结构4、模式匹配算法及其改进算法★★课时分配：1、2，两个学时，3两个学时, 4 四个学时，上机6个学时★★★重点、难点：模式匹配及其算法第一节．串的定义和基本运算串是字符串的简称。
它是一种在数据元素的组成上具有一定约束条件的线性表，即要求组成线性表的所有数据元素都是字符，所以，人们经常又这样定义串：串是一个有穷字符序列。
串一般记作：s= "a1a2...an" (n30)其中，s是串的名称，用双引号（""）括起来的字符序列是串的值；ai可以是字母、数字或其他字符；串中字符的数目n被称作串的长度。
当n=0时，串中没有任何字符，其串的长度为0，通常被称为空串。
s1= ""s2= " "s1中没有字符，是一个空串；而s2中有两个空格字符，它的长度等于2，它是由空格字符组成的串，一般称此为空格串。
概念：子串、主串：串中任意连续的字符组成的子序列被称为该串的子串。
包含子串的串又被称为该子串的主串。
例如，有下列四个串a，b，c，d：a= "Welcome to Beijing"b= "Welcome"c= "Bei"d= "welcometo"子串的位置：子串在主串中第一次出现的第一个字符的位置。
两个串相等：两个串的长度相等，并且各个对应的字符也都相同。
例如，有下列四个串a，b，c，d：a= "program"b= "Program"c= "pro"d= "program "串的基本操作：（1）创建串StringAssign (s,string_constant)（2）判断串是否为空StringEmpty(s)（3）计算串长度Length(s)（4）串连接Concat(s1,s2)（5）求子串SubStr(s1,s2start,len)（6）串的定位Index(s1,s2)例如1：将s2串插入到串s1的第i个字符后面。
实现串的基本操作
实现串的基本操作1. 什么是串？串是由零个或多个字符组成的有限序列。
它是计算机科学中非常重要的一个数据结构，在各种应用程序中广泛使用。
串可以包含任意类型的字符，比如字母、数字、符号等。
在实际编程中，我们通常使用字符串来表示和操作串。
2. 串的基本操作对于串的基本操作，主要包括以下几个方面：2.1. 初始化串初始化串即创建一个新的空串。
在很多编程语言中，可以使用特定的语法来初始化一个空串，比如在C语言中，可以使用char s[MAX_LEN] = ""来初始化一个空串。
在其他一些编程语言中，可以使用空串字面量来表示一个空串。
2.2. 求串的长度求串的长度是指得到一个串中字符的个数。
对于一个已知的串，我们可以通过遍历字符串并统计字符个数来求得它的长度。
在很多编程语言中，也提供了现成的函数或方法来直接获取串的长度。
2.3. 比较串比较串是指判断两个串是否相等。
在很多编程语言中，可以使用==运算符来比较两个串是否相等。
需要注意的是，在比较两个串时，通常要考虑区分大小写和字符编码等因素。
2.4. 复制串复制串即将一个串的内容复制到另一个串中。
在很多编程语言中，都提供了现成的函数或方法来实现串的复制操作。
2.5. 连接串连接串是指将两个或多个串拼接成一个新的串。
在很多编程语言中，可以使用特定的运算符或函数来实现字符串的连接操作。
3. 串的实现方式3.1. 顺序存储顺序存储是指将串的字符按照顺序存储在一片连续的存储空间中。
在顺序存储的方式下，我们可以通过数组来实现串的基本操作。
其中，数组的每个元素对应于串的每个字符。
3.2. 链式存储链式存储是指使用链表来存储串的字符。
在链式存储的方式下，每个节点包含一个字符和一个指向下一个节点的指针。
通过这种方式，可以方便地插入和删除字符。
4. 示例代码下面以C语言为例，给出一个简单的串的实现示例：#include <stdio.h>#include <stdlib.h>typedef struct Node {char data;struct Node* next;} Node;typedef struct {Node* head;int length;} String;// 初始化串void initString(String* string) {string->head = NULL;string->length = 0;}// 求串的长度int getLength(String string) {return string.length;}// 比较串int compareString(String string1, String string2) {Node* p = string1.head;Node* q = string2.head;while (p != NULL && q != NULL && p->data == q->data) { p = p->next;q = q->next;}if (p == NULL && q == NULL) {return 0;} else if (p == NULL) {return -1;} else if (q == NULL) {return 1;} else {return p->data - q->data;}}// 复制串void copyString(String* target, String source) {Node* p = source.head;target->head = NULL;target->length = 0;while (p != NULL) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = p->data;newNode->next = NULL;if (target->head == NULL) {target->head = newNode;} else {Node* q = target->head;while (q->next != NULL) {q = q->next;}q->next = newNode;}target->length++;p = p->next;}}// 连接串void concatString(String* target, String string1, String string2) { target->head = NULL;target->length = 0;Node* p = string1.head;while (p != NULL) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = p->data;newNode->next = NULL;if (target->head == NULL) {target->head = newNode;} else {Node* q = target->head;while (q->next != NULL) {q = q->next;}q->next = newNode;}target->length++;p = p->next;}p = string2.head;while (p != NULL) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = p->data;newNode->next = NULL;Node* q = target->head;while (q->next != NULL) {q = q->next;}q->next = newNode;target->length++;p = p->next;}}// 销毁串void destroyString(String* string) {Node* p = string->head;while (p != NULL) {Node* next = p->next;free(p);p = next;}string->head = NULL;string->length = 0;}int main() {String string1, string2, string3;initString(&string1);initString(&string2);initString(&string3);// 初始化串Node* node1 = (Node*)malloc(sizeof(Node));node1->data = 'H';node1->next = NULL;Node* node2 = (Node*)malloc(sizeof(Node));node2->data = 'e';node2->next = NULL;Node* node3 = (Node*)malloc(sizeof(Node));node3->data = 'l';node3->next = NULL;Node* node4 = (Node*)malloc(sizeof(Node));node4->data = 'l';node4->next = NULL;Node* node5 = (Node*)malloc(sizeof(Node));node5->data = 'o';node5->next = NULL;string1.head = node1;node1->next = node2;node2->next = node3;node3->next = node4;node4->next = node5;string1.length = 5;// 求串的长度int length = getLength(string1);printf("The length of the string is: %d\n", length);// 比较串initString(&string2);Node* node6 = (Node*)malloc(sizeof(Node));node6->data = 'H';node6->next = NULL;Node* node7 = (Node*)malloc(sizeof(Node));node7->data = 'e';node7->next = NULL;Node* node8 = (Node*)malloc(sizeof(Node));node8->data = 'l';node8->next = NULL;Node* node9 = (Node*)malloc(sizeof(Node));node9->data = 'l';node9->next = NULL;Node* node10 = (Node*)malloc(sizeof(Node));node10->data = 'o';node10->next = NULL;string2.head = node6;node6->next = node7;node7->next = node8;node8->next = node9;node9->next = node10;string2.length = 5;int result = compareString(string1, string2);if (result == 0) {printf("The two strings are equal.\n");} else if (result < 0) {printf("String1 is smaller than string2.\n"); } else {printf("String1 is larger than string2.\n"); }// 复制串copyString(&string3, string1);printf("The copied string is: ");Node* p = string3.head;while (p != NULL) {printf("%c", p->data);p = p->next;}printf("\n");// 连接串concatString(&string3, string1, string2);printf("The concatenated string is: ");p = string3.head;while (p != NULL) {printf("%c", p->data);p = p->next;}printf("\n");// 销毁串destroyString(&string1);destroyString(&string2);destroyString(&string3);return 0;}5. 总结串是计算机科学中重要的数据结构，用于表示和操作由字符组成的有限序列。
数据结构串的基本操作及应用实验报告(常用版)
数据结构串的基本操作及应用实验报告（常用版）(可以直接使用，可编辑完整版资料，欢迎下载）实验日期2021.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:{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;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语言水平有待提高。
串的基本操作
实验七串的基本运算实验时间2011-4-19实验地点：机房2实验目的：(1)掌握串的特点及其顺序定长存储方式。
（2）掌握串的创建、连接、插入、删除、显示、查找、取子字符串、比较串的大小的操作（3）掌握模式匹配的思想和算法。
1、问题描述串是一种特殊的线性表，串中所有数据元素都按某种次序排列在一个序列中。
串是由0个或多个字符构成的有限序列。
线性表有两种存储结构：顺序存储和链式存储，串是一种特殊的线性表，因此也有两种基本存储结构：顺序串和链式串。
采用顺序存储时，串是用一块地址连续的存储单元来存储串值。
串链式存储时，链表中每个结点可以存放一个字符，也可以存放多个字符。
串的模式匹配即子串定位。
设s和t是给定的两个串，在主串s中找到子串t的过程称为模式匹配。
如果在主串s中找到子串t，则匹配成功，函数返回子串t在主串s中首次出现的存储（或序号）；否则匹配不成功，返回-1。
2、数据结构设计串的数据类型：typedef struct{char vec[STRINGMAX]int len;}str;3、功能（函数）说明串的基本操作：void ConcatStr(str *r1,str *r2) //连接字符串void SubStr(str *r,int i,int j) //取出子字符串void DelStr(str *r，int i，int j) //删除子字符串str *InsStr(str *r,str *r1,int i) //插入子字符串int InDexStr(str *r,str *r1) //查找子字符串int LenStr(str *r) //计算字符串长度int EqualStr(str *r1,str *r2) //比较字符串大小4、界面设计指导用户按照正确的格式输入数据。
5、编码实现#include<stdio.h>#define STRINGMAX 100typedef struct{char vec[STRINGMAX];int len;void ConcatStr(str *r1, str *r2) //串连接{int i;printf("\n.t.tr1=%s r2=%\n ", r1->vec, r2->vec);if (r1->len+r2->len> STRINGMAX)// 连接后的串长超过串的最大长度printf("\n\t\t两个串太长，溢出！\n");else{for(i=0;i<r2->len;i++)r1->vec[r1->len+i]=r2->vec[i]; //进行连接r1->vec[r1->len+i]='\0';r1->len=r1->len+r2->len; //修改连接后新串的长度}}void SubStr(str *r,int i,int j)//求子串{int k;str a;str *r1=&a;if(i+j-1>r->len){printf("\n\t\t字串超界！\n");return;}else{for(k=0;k<j;k++)r1->vec[k]=r->vec[i+k-1]; //从r中取出子串r1->len=j;r1->vec[r->len]='0';}printf("\n\t\t取出字符为: ");puts (r1->vec);}void DelStr(str *r, int i, int j)//删除子串,i指定位置,j为连续删除的字符个数{int k;if(i+j-1>r->len)printf("\n\t\t所要删除的子串超界！\n");else{for(k=i+j;k<r->len;k++,i++)r->vec[i]=r->vec[k]; //将后面字符串前移覆盖r->len=r->len-j;r->vec[r->len]='\0';}str *InsStr(str *r,str *r1,int i){int k;if(i>=r->len || r->len+r1->len>STRINGMAX)printf("\n\t\t不能插入！\n");else{for(k=r->len-1;k>=i;k--)r->vec[r1->len+k]=r->vec[k]; //后移空出位置for(k=0;k<r1->len;k++)r->vec[i+k]=r1->vec[k]; //插入子串r1r->len=r->len+r1->len;r->vec[r->len]='\0';}return r;}int IndexStr(str *r, str *r1){int i,j,k;for(i=0;r->vec[i];i++)for(j=i,k=0;r->vec[j]==r1->vec[k];j++,k++)if(!r1->vec[k+1])return i;return -1;}int LenStr(str *r){int i=0;while(r->vec[i]!='\0')i++;return i;}str *CreateStr(str *r){gets(r->vec);r->len=LenStr(r);return r;}int EqualStr(str *r1,str *r2){for(int i=0;r1->vec[i]&&r2->vec[i]&&r1->vec[i]==r2->vec[i];i++); return r1->vec[i]-r2->vec[i];}void main(){str a,b,c,d;str *r=&a,*r1;r->vec[0]='\0';char choice, p;int i,j,ch=1;while(ch!=0){printf ("\n");printf("\n\t\t串的基本操作");printf("\n\t\t******************");printf("\n\t\t* 1-----输入字串*");printf("\n\t\ t* 2-----连接字串*");printf("\n\t\ t* 3-----取出字串*");printf("\n\t\ t* 4----删除字串*");printf("\n\t\ t* 5-----插入字串*");printf("\n\t\ t * 6-----查找字串*"); printf("\n\t\ t* 7-----比较串大小*"); printf("\n\t\ t* 8-----显示字串*"); printf("\n\t\ t* 0-----返回*"); printf("\n\t\ t**********************"); printf("\n\t\ t请选择菜单号（0-8）: ");scanf ("%c", &choice);getchar();if(choice=='1'){printf("\n\t\ t请输入字符串：");gets(r->vec);r->len=LenStr(r);}else if(choice=='2'){printf("\n\t\ t请输入所要连接的串：");r1=CreateStr(&b);ConcatStr(r,r1);printf("\n\t\t连接以后的新串值为：");puts(r->vec);}else if(choice=='3'){printf("\n\t\ 请输入从第几个字符开始：");scanf("%d",&j);getchar();SubStr(r,i,j);}else if(choice=='4'){printf("\n\t\t 请输入从第几个字符开始：");scanf("%d",&i);getchar();printf("\n\t\t请输入删除的连续字符数：");scanf("%d",&j);getchar();DelStr(r,i-1,j);}else if(choice=='5'){printf("\n\t\t 请输入从第几个字符开始：");scanf ("%d",&i);getchar();printf("\n\t\t请输入所要插入的字符串：");r1=CreateStr(&b);InsStr(r,r1,i-1);}else if(choice=='6'){printf("\n\t\t请输入所要查找的字符串：");r1=CreateStr(&b);i=IndexStr(r,r1);if(i=-1)printf("\n\t\t第一次出现的位置是第%d个。
第四章串的基本操作
}
//算法4.5
//返回子串T在主串S中第pos个字符之后的位置，若不存在，则函数值为0
int Index(SString S,SString T,int pos)
{
int i,j;
if(1<=pos&&pos<=S[0])
{
i=pos;
j=1;
while(i<=S[0]&&j<=T[0])
串的基本操作：
程序代码：
#include<stdio.h>//注意，S[0]放长度，循环i从什么地方开始。
#include<stdlib.h>
#include<string.h>//串的定长顺序存储结构（基本操作13个），SString是数组，故不需引用类型
#define OK 1
#define ERROR 0
printf("串长超过MAX_STR_LEN(=%d)\n",MAX_STR_LEN);
exit (0);
}
printf("串长为%d串空否？%d(1：是0：否)\n",StrLength(S1),StrEmpty(S1));
StrCopy(S2,S1);
printf("拷贝S1生成的串为");
StrPrint(S1);
for(i=pos;i<pos+T[0];i++)
S[i]=T[i-pos+1];
S[0]+=T[0];
return TRUE;
}
else
{//部分插入
for(i=MAX_STR_LEN;i>=pos+T[0];i--)
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1上机实训3：串的基本操作一、实训目的通过实训，掌握串的运算（赋值，比较，联结，插入子串，模式匹配……等）二、实验理论知识1)串的基本概念及其含义串( string)是由零个或多个字符组成的有限序列，一般记作:s='a1a2…an'(n≥0)，其中s为串的名字，用单引号括起来的字符序列为串的值；ai(1≤i≤n)可以是字母、数字或其它字符（取决于程序设计语言所使用的字符集）；n为串中字符的个数，称为串的长度。
2)串的存储表示及其实现●顺序存储可以用一组地址连续的存储单元依次存放串的各个字符，这是串的顺序存储结构，也称为顺序串●链式存储和线性表的链式存储结构相类似，也可采用链表方式存储串值。
串的这种链式存储结构简称为链串。
用链表存储字符串，每个结点需要有两个域：一个数据域（data）和一个指针域(Next)，其中数据域存放串中的字符，指针域存放后继结点的地址。
3)模式匹配问题三、实训案例与分析【实例1】串的存储与基本运算【实例分析】在本实例中练习计算字符串的长度、字符串的复制、字符串的比较、字符串的连接、字符串的插入等基本操作。
在设计时1)编写一个菜单函数，根据不同情况做（1-5）不同选择。
2)如果选择1，即要求计算输入字符串的长度。
3)如果选择2，完成字符串的复制。
4)如果选择3，完成字符串的比较。
5)如果选择4，完成两个字符串的连接。
6)如果选择5，字符串的插入。
【参考程序】#include <stdio.h>#define MAX 128typedef enum {fail,success} status;typedef enum {false,true} boolean;main(){ int strlen();void strass();boolean strcmp();status strcat( );status strins();int t,n,i;boolean b;status st;char s[MAX],s1[MAX],s2[MAX];printf("\n1. The length of string\n");printf(" 2. The assignment of string\n");printf(" 3. A string compare with another string:\n");printf(" 4. A string connect with another string:\n");printf(" 5. A string to be inserted into another string\n"); printf(" Please input a operation:");/*输入操作选项*/scanf("%d",&t);switch(t){case 1:printf("please input a string:\n");getchar();gets(s);n=strlen(s);printf("the length is: %d",n);break;case 2:printf("please input the first string:\n");getchar();gets(s1);printf("please input the second string:\n");getchar();gets(s2);strass(s1,s2);break;case 3:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string: \n"); gets(s2);b=strcmp(s1,s2);if (b==true)printf("equal\n");elseprintf("not equal\n");break;case 4:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string:\n"); gets(s2);st=strcat(s1,s2);if(st==success)printf("answer is %s\n",s1);elseprintf("error!\n");break;case 5:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string:\n"); gets(s2);printf("please input i:");scanf("%d",&i);st=strins(s1,i,s2);if(st==success)printf("answer is: %s\n",s1);else printf("error!\n");break;case 0:break;default: printf("There isn't this operation!");}}int strlen(s) /*求字符串的长度子函数*/char s[];{ int i;for(i=0;s[i]!='\0';i++);return (i);}void strass(s1,s2)char s1[],s2[];{ int i=0;while(s1[i]!='\0'){ s2[i]=s1[i];i++;}s2[i]='\0';printf("s2 is %s",s2);}boolean strcmp(s1,s2) /*字符串比较子函数*/char s1[],s2[];{ int i=0;while (s1[i]==s2[i] && s1[i]!='\0' && s2[i]!='\0') i++;if (s1[i]=='\0' && s2[i]=='\0')return (true);elsereturn (false);}status strcat (s1,s2) /*字符串连接子函数*/char s1[],s2[];{ int i,j,k;i=strlen(s1);j=strlen(s2);if((i+j)>=MAXN)return(fail);for(k=0;k<=j;k++)s1[i+k]=s2[k];return (success);}status strins (s1,i,s2)char s1[],s2[];int i;{ int m,n,k;m=strlen(s1);n=strlen(s2);if (i<0||i>m||(m+n)>MAXN )return (fail) ;for(k=m;k>=i;k--)s1[k+n]=s1[k];for(k=0;k<n;k++)s1[i+k]=s2[k];return (success);}【测试数据与结果：】计算字符串的长度1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:1please input a string:you are a boy!the length is: 14字符串的复制1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:2please input the first string:you are a boy!please input the second string:i am a girl!s2 is you are a boy!字符串的比较1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:3please input the first string:you are a boy!please input the second string:i am a girl!not equal字符串的连接1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another stringPlease input a opertation:4please input the first string:you are a boy!please input the second string:i am a girl!answer is： you are a boy!i am a girl!字符串的插入1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another stringPlease input a opertation:5please input the first string:you are a boy!please input the second string:i am a girl!please input i:2answer is i am a girl! you are a boy!【实例2】统计主串指定单词在主串中出现的次数和位置【实例描述】统计主串指定单词在主串中出现的次数和位置，要求：1)输入以回车作为结束符的一串字符作为主串；2)求主串中指定单词出现的次数和位置，注意单词与子串的区别；【实例分析】假设num存放出现次数，初始化为0，position[i]存放每一次匹配时的位置。