数据结构实验四字符串的应用
数据结构串的基本操作及应用实验报告
实验日期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. 字符串的应用字符串在计算机科学中有广泛的应用,以下是几个典型的应用场景:•文本处理:字符串可以用于处理文本数据,包括读取和分析文本文件、编写文本编辑器等。
•数据传输:在网络通信中,字符串经常用于传输数据,例如传输文件、发送邮件等。
•数据库操作:字符串在数据库中扮演重要的角色,用于存储和查询数据,例如SQL语句中的查询条件和结果。
•编程语言:字符串是几乎所有编程语言的基本数据类型,用于表示文本信息和操作字符串。
实验步骤1.创建一个字符串变量,并赋予其初始值。
2.执行字符串拼接操作,将两个字符串连接为一个新的字符串。
3.使用字符串截取操作,从拼接后的字符串中截取出指定范围的子串。
4.执行字符串替换操作,将指定的字符或子字符串替换为新的字符或子字符串。
5.使用字符串查找操作,查找指定字符或子字符串在字符串中的位置或索引值。
实验结果和分析经过以上实验步骤,我们可以观察到字符串的各种操作的效果。
通过拼接操作,我们可以将两个字符串连接为一个新的字符串,这在实际开发中常用于生成动态的文字信息。
通过截取操作,我们可以从一个较长的字符串中提取出所需的部分,这在处理大文本数据时很有用。
数据结构与算法分析第四章字符串
// 0号单元存放串的长度
特点: 串的实际长度可在这个予定义长
度的范围内随意设定,超过予定义 长度的串值则被舍去,称之为 “截断”
按这种串的表示方法实现的串的 运算时,其基本操作为 “字符序列 的复制”
例如
串值的存储
我们称串是一种特殊的线性表,因此串的存储结构表示也有两种方法:静态存 储采用顺序存储结构,动态存储采用的是链式存储和堆存储结构。
1.串的静态存储结构
类似于线性表的顺序存储结构,用一组地址连续的存储单元存储串值的字符序
列。由于一个字符只占1个字节,而现在大多数计算机的存储器地址是采用的字
编址,一个字(即一个存储单元)占多个字节,因此顺序存储结构方式有两种:
串的联接算法中 需分三种情况处理
Concat(SString S1, SString S2,
SString &T) {
if(S1[0]+S2[0]<=MAXSTRLEN){//未截断
eTTTleTsTT[[[le1S0s[[[0e.]1Si.f.S[.=1{..0M(1S[/S]S0[/1+0A11]S截[1+][[0X2]0.01].断[]=S]]S.1S.+<1M=T.S1(S.[M仅MR[10S2A0[][1LAA.取1+X0.[ME.XS]1X.S;SS.N2ST.SA11S[T]T0R)u[X10=]RnR[L]S]0cS]LET=];uI]ENRtZ;SN=]L2E[T=-E)1R{N..SSU/]1/;2E[截[00;]]断]];; }
式存语言中采用字符'\0'作串值的结束符。串s
串的应用实验报告小结
串的应用实验报告小结实验目的:本实验旨在探索串的应用,并通过实际操作,加深对串的理解和应用能力。
实验原理:串是计算机中常用的数据类型,表示一个字符序列。
在实际应用中,串具有很强的灵活性和实用性,可以用于字符串的处理、文本处理、数据传输等场景。
串的基本操作包括串的定义、串的赋值、串的连接、串的比较、串的查找、串的替换等。
实验仪器和材料:编程环境:本实验使用Python编程语言进行实验操作。
实验过程中需要使用字符串处理相关的函数和方法。
实验步骤:1. 串的定义与赋值:首先介绍串的定义方法,并进行一些基本的赋值操作,包括直接赋值和通过输入获取串的赋值。
2. 串的连接:实现两个串的连接操作,了解串的拼接方式及其应用场景。
3. 串的比较:通过比较两个串的内容,了解串的比较操作及其返回值的含义。
4. 串的查找与替换:实现对串的查找和替换操作,掌握相关函数的用法并思考其实际应用。
实验结果:通过本次实验,我对串的相关操作有了更深入的了解。
掌握了串的基本定义、赋值、连接、比较、查找和替换等操作,并能够将其应用到实际问题中。
在实验过程中,我学会了如何利用串来处理文本数据,进行查找和替换操作,以及如何利用串的连接来构造更复杂的字符串。
这些知识和实践经验对我的编程能力和问题解决能力都有所提高。
实验总结:通过本次实验,我对串的基本概念和相关应用有了更深入的了解。
串作为计算机中重要的数据类型,在实际应用中有着广泛的应用场景,掌握了串的相关操作,将对我的日常编程工作和问题解决能力产生积极的影响。
串的处理能力将对字符串处理、文本处理、数据传输等方面有很大帮助。
结语:本次实验使我更加深入地理解了串的概念及其在实际应用中的作用。
通过在实验中动手操作,我对串的相关操作有了更深入的了解,相信这将对我的编程能力和问题解决能力有所提升。
我也意识到了串在计算机领域的重要性和广泛的应用前景,将积极应用串的相关知识到我的日常工作和学习中。
串-数据结构实验报告
串-数据结构实验报告串数据结构实验报告一、实验目的本次实验的主要目的是深入理解和掌握串这种数据结构的基本概念、存储方式以及相关的操作算法。
通过实际编程实现串的基本操作,提高对数据结构的理解和编程能力,培养解决实际问题的思维和方法。
二、实验环境本次实验使用的编程语言为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、连接操作成功实现,输出了正确连接后的字符串。
串的数据结构实验报告
串的数据结构实验报告
《串的数据结构实验报告》
在计算机科学领域,数据结构是非常重要的基础知识之一。
而串(String)作为一种基本的数据结构,在实际应用中也扮演着重要的角色。
本实验报告将介绍串的数据结构以及在实验中的应用和表现。
首先,串是由零个或多个字符组成的有限序列,是一种线性表。
在计算机中,串通常用来表示文本数据,比如字符串、文件名等。
在实际应用中,串的操作非常频繁,比如查找、替换、插入、删除等。
因此,对串的数据结构进行深入的研究和实验是非常有意义的。
在本次实验中,我们选择了C语言作为实验的编程语言,使用指针和动态内存分配来实现串的数据结构。
我们首先定义了一个结构体来表示串,结构体中包括串的长度和字符数组指针。
然后,我们实现了一系列操作函数,比如串的初始化、销毁、拷贝、连接、比较等。
通过这些操作函数,我们可以对串进行各种操作,从而验证串的数据结构的有效性和实用性。
在实验过程中,我们发现串的数据结构在实际应用中表现出了很好的性能和灵活性。
比如,在进行串的连接操作时,我们可以直接使用指针进行操作,而不需要额外的内存开销。
在进行串的比较操作时,我们可以逐个字符进行比较,从而实现高效的比较操作。
这些实验结果表明,串的数据结构在实际应用中具有很高的实用价值。
总的来说,本次实验对串的数据结构进行了深入的研究和实验,验证了串的数据结构在实际应用中的有效性和实用性。
通过本次实验,我们对串的数据结构有了更深入的理解,也为以后的实际应用提供了参考和借鉴。
希望本次实验报
告能对读者有所帮助,也希望能够对串的数据结构进行更深入的研究和探索。
实验报告四:字符串实验
实验报告
实验四字符串实验(2学时)
实验目的:
掌握有关字符串的基本操作和存储结构,并编写相应的基本操作算法。
实验内容:(类C算法的程序实现,任选其二)
(1) 求字符串的长度算法(必做);
(2) 求字符串的子串算法(选做);
(3) 字符串的合并算法(选做);
(4) 字符串的置换算法(选做);
(5) 字符串的插入算法(选做)。
实验准备:
1)计算机设备;2)程序调试环境的准备,如TC环境;3)实验内容的算法分析与代码设计与分析准备。
实验步骤:
1.录入程序代码并进行调试和算法分析;
2.编写实验报告。
实验结果:
试验的完整的C程序代码,以及程序实现与结果分析。
(1)字符串的数据结构定义:
(2)给串赋值:
(3)求串的长度:
(4)串的比较:
(5)给串插入值:
(6)输出串:
(7)截取子串:
(8)主函数:(目的:建立字符串,并实现输出,求长度,求字串等基本操作)
(9)程序结果
分析:第一次输出结果为此结果,最后检查为把串的定义写错了,无法再显示最终结
果
这是改过之后输出的结果。
《数据结构》课程实验报告四关于字符串的操作
《数据结构》课程实验报告四串班级:418教育技术班学号: 2018744109姓名:邓远义实验目的和要求:1.理解掌握串的有关概念和基本运算实现。
2.掌握模式匹配等串的典型算法。
二、实验内容:(给出具体的说明文字和拍摄的图片)1.已知字符串采用顺序存储结构定义如下,请编写函数int SubString(SeqString *sub, SeqString S, int pos, int len),在字符串 s 中从第 i 个位置起取长度为 len 的子串复制到sub中,复制成功函数返回1,否则返回0。
#include "stdio.h"#include "string.h"#define MAXLEN 100typedef struct{char ch[MAXLEN];int last;//指向最后一个字符的位置} SeqString;/*请将本函数补充完整,并进行测试*/int SubString(SeqString *sub, SeqString s, int pos, int len) {int i;if(pos<0||pos>st||len<1||len>st-pos){sub->last=0;return 0 ;}else{for(i=0;i<len;i++){sub->ch[i]=s.ch[i+pos-1];//(i+pos是数组下标所以要减一)}sub->last=len;sub->ch[i]='\0';//不能丢,会乱码,为什么?目前不清楚//是不是len的值没赋引起的?return 1;}}void main(){SeqString sub,s;int pos,len,n;printf("请输入一个字符串(以回车结束):\n");gets(s.ch);st=strlen(s.ch);//strlen()返回字符串的长度printf("请输入pos和len的值:");scanf("%d%d",&pos,&len);n=SubString(&sub,s, pos, len);if(n)//n!=NULL{puts(sub.ch);}elseprintf("取串不成功\n");}/*请输入一个字符串(以回车结束):DengYuanYi请输入pos和len的值:4 4Yuan烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫.会乱码的原因是需要加结束符sub->ch[i]='\0'; 否则直到把maxsize填满*/2. 已知字符串采用顺序存储结构定义如下,请设计算法函数int StrDelete(SeqString *S, int pos, int len),在字符串 s 中删除从第 i 个位置开始,长度为 len 的子串,删除成功,函数返回值为1,否则为0。
串及其应用的实验报告
一、实验目的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!”的串,验证了串的创建功能。
数据结构串的实验报告
HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY数据结构程序设计实验报告03实训题目:串的构造与应用(自行编写)专业:软件工程班级: 软件 161 姓名:王洋学号: 201600819 完成日期: 2017年11月5日2017年11月目录一实验前提 (3)一、1. 实验序言 (3)一、2. 实验目的 (3)一、3. 实验背景 (3)一、4. 实验方式 (4)二程序原理 (4)二、1. 设计思路 (4)二、2. 实验原理 (4)三程序设计 (6)三、1. 主要功能 (6)三、2. 程序界面 (6)四功能实现 (7)四、1. 串的初始化 (7)四、2. 串的插入和删除 (8)四、3. 串的修改及提取子串 (9)四、4. 程序调试 (10)四、5. 程序细节 (10)四、6. 要点函数功能源码 (11)五 }程序总结 (12)五、1. 程序收获清单 (12)五、2. 程序不足改进 (12)六实验总结 (12)一实验前提一、1. 实验序言每一次实验都是一种历练和进步,至少在每次进行序言的时候,都会去总结和想办法改进程序。
即使能力有限,我也切身感受到了进步,以及进步后对程序的稍微深度地思考。
而这次对于串的实验,显然让我感受到了,这样的思考非常欠缺,我所需要完成的还有很多,尤其是随着功能的完善,和深入的编程,会发现其中有更多的地方需要我去改进,尤其是功能越多越深入,这种感觉就越明显一、2. 实验目的串的基本操作的编程实现(2学时,验证型),掌握串的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、合并、剪裁等操作,存储结构可以在顺序结构或链接结构、索引结构中任选,也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
一、3. 实验背景在较熟练的掌握关于对象的编程方法后,这次我就改用了C++进行编写,而且难度要比我预期的要低,效果反而更好了。
同时,串基于字符数组实现要容易得多,而且对于一维数组的具体操作,已经相对较为熟练,而且也提供了很多关于字符串的相关函数,所以为了提高编程水平,这次对于串的操作,都不依赖系统函数和字符串函数,相反,深入初始化,插入,删除,遍历等功能的本质,对字符串的底层进行编程实现。
第4章 字符串的使用
"你好,{1},你这个月的工资是{0}元!".format(8500,"张三")
如果大括号中没有序号,则按照出现顺序替换
例如:
"你好,{},你这个月的工资是{}元!".format(8500,"张三")
4.2.2 使用format()方法进行格式化
字符串格式化操作
format()方法中模板字符串的槽除了包括参数序号外,还可以包括格式控制信息,此时槽的内部样式为:
字符串方法
2.count()方法
count()方法用于统计字符串里某个子串出现的次数。该函数返回子串在字符串中出现的次数。
str.count(sub[,start[,end]])
str表示被查找字符串; sub表示要统计的子串; start表示开始索引,省略时默认为0; end表示结束索引,省略时默认为字符串的长度。
程序运行效果
4.2.1 使用符号“%”进行格 式化
4.2.2 使用format()方法进行 格式化
4其指 输 指 输.一定出定出2.般左“右“1形+-对对””式齐齐使时时为;。,,用: 符义于用号的定十宽义“进度的制%,宽整则度”数补,m进空来则格表按行或示实格0输际(出位式如的数在化最输m少出前位;有数若数。实字格若际0式,实位字则际数符补位少用0数于字)多定。符串格式化操作
>>> new_str = "This is an example of cutting" #创建字符串
例:编写程序,要求利用序列的乘 法运算输出如下图所示的文字格式。
strs="I love Python!“ print(" "*10+"-"*15) 10个空格和15个“-” print(" "*30) print(" "*10+strs) print(" "*30) print(" "*10+"-"*15)
数据结构实验报告五—四则运算表达式求值
问题描述:四则运算表达式求值,将四则运算表达式用中缀表达式,然后转换为后缀表达式,并计算结果。
一、需求分析:1、本程序是利用二叉树后序遍历来实现表达式的转换,同时可以使用实验三的结果来求解后缀表达式的值。
2、输入输出格式:输入格式:在字符界面上输入一个中缀表达式,回车表示结束。
请输入表达式:输入一个中缀表达式输出格式:如果该中缀表达式正确,那么在字符界面上输出其后缀表达式,其中后缀表达式中两相邻操作数之间利用空格隔开;如果不正确,在字符界面上输出表达式错误提示。
逆波兰表达式为:输出逆波兰表达式运算结果为:输出运算后的结果3、测试用例输入:21+23*(12-6)输出:21 23 12 6 -*+二、概要设计:抽象数据类型二叉树类BiTree算法的基本思想根据题目要求,利用栈计算,和二叉树存储,来计算表达式该算法的基本思想是:先利用栈进行计算,然后用二叉树进行存储,和实验三算法一样来计算逆波兰表达式的值程序的流程程序由三个模块组成:(1)输入模块:输入一个运算式(2)计算模块:利用栈进行表达式的计算,二叉树来存储。
(3 )输出模块:屏幕上显示出后缀表达式和运算结果。
三、详细设计物理数据类型程序含有两个类,其中栈不再赘述,另一个类为二叉树class BiTree 包含私有成员struct BiTreeNode,根节点BiTreeNode *T;索引index; int number_of_point 优先级比较函数 compare(char a,char b);生成树的函数void InorderCreate(BiTreeNode *&T,char str[30][10],int start,int end);判断数字函数bool IsNumber(char a);求值函数double Operate(BiTreeNode *T);还有显示后缀表达式的函数void display(BiTreeNode *T) ;而公有成员函数则是对私有函数的重载,为方便使用,因为函数中普遍使用了递归的算法。
实验 字符串操作
实验四字符串操作一、实验目的1.练习使用字符串操作类指令2.掌握字符串操作类指令的寻址方式二、实验环境1.硬件:PC微机2.软件:DOS系统、EDIT.EXE、MASM.EXE、LINK.EXE、DEBUG.EXE三、实验内容1.实验题目将数据段BLOCK中的16个数据按正负数分开存储,正数(包含0)存放在DPLUS中,负数存放在DMINUS中。
2.编程提示(1)取数使用LODSB,从DS:[SI]中取一个字节数据到AL中。
(2)使用TEST AL,80H,判断AL的符号位是0还是1(3)存数使用STOSB,将AL中的数据存入ES:[DI]。
3.参考程序STACK SEGMENT STACKDW 256 DUP (?)TOP LABEL WORDSTACK ENDSDA TA SEGMENTBLOCK DB 56H,23H,5AH,6FH,88H,95H,7FH,0F1HDB 81H,0E5H,0A1H,5DH,87H,65H,23H,19HDPLUS DB 16 DUP (0)DMINUS DB 16 DUP (0)DA TA ENDSCODE SEGMENTASSUME CS:CODE,DS:DA TA,SS:STACKSTART:MOV AX,DATAMOV DS,AXMOV ES,AXMOV AX,STACKMOV SS,AXMOV SP,OFFSET TOPLEA SI,BLOCKLEA DI,DPLUSLEA BX,DMINUSMOV CX,10HCLDNEXT:LODSBTEST AL,80HJNZ MINUSSTOSBJMP AGAINMINUS:XCHG BX,DISTOSBXCHG BX,DIAGAIN:LOOP NEXTDONE:MOV AH,4CHINT 21HCODE ENDSEND START4.调试(1)用U命令进行反汇编,查看BLOCK、DPLUS、DMINUS在数据段中的偏移量。
数据结构 第四章 串
第四章串串又称字符串,是一种特殊的线性表,它的每个元素仅由一个字符组成。
计算机上非数值处理的对象基本上是字符串数据。
在较早的程序设计语言中,字符串仅作为输入和输出的常量出现。
随着计算机应用的发展,在越来越多的程序设计语言中,字符串也可作为一种变量类型出现,并产生了一系列字符串的操作。
在信息检索系统、文字编辑程序、自然语言翻译系统等等应用中,都是以字符串数据作为处理对象的。
本章将讨论串的存储结构和基本操作。
4.1 串的基本概念4.1.1 串的自然语言定义串(string)(或字符串)是由零个或多个字符组成的有限序列,一般记为:S="a1 a2 …… a n" (n≥0)其中,S是串名,用双引号括起来的字符串序列是串的值;a i(1≤i≤n)可以是字母、数字或其他字符;串中字符的个数n称为串的长度。
长度为0的串称为空串。
需要注意的是,串值必须用一对双引号括起来,但双引号本身不属于串,它的作用只是为了避免与变量名或数的常量混淆。
如"tempt"是个串,tempt则是变量名;"23"是串,而23则是一个常量.串中任意个连续的字符组成的子序列称为该串的子串,如:串S="This is a string",其中"This"是一个子串,"string"也是一个子串。
求子串在串中的起始位置称为子串定位或模式匹配。
例如,设A,B,C为如下三个串:A="data",B="structure",C="data structure",则它们的长度分别是4,9,14,A和B都是C的子串,A在C中的位置是1,而B在C中的位置是6。
下面注意区别空格串与空串的概念。
在各种应用中,空格常常是串的字符集合中的一个元素,因而可以出现在其他字符中间。
由一个或多个空格组成的串称为空格串,也就是说空格串中只有空格字符,空格串的长度不为零。
数据结构串的应用及其基本操作_课程设计实验报告
printf("请输入原字符串和其长度:");
scanf("%s%d",s,&s->curlen);
printf("请输入要插入的字符串的长度:");
scanf("%s%d",t,&t->curlen); for(j=s->curlen-1;j>=i;j--) s->ch[j+t->curlen]=s->ch[j]; for(k=0,j=i;t->ch[k]!='\0';k++,j++) s->ch[j]=t->ch[k]; s->ch[s->curlen+t->curlen]='\0'; s->curlen=s->curlen+t->curlen;
4
printf("插入后的字符串为:");
puts(s->ch); }
void deletes(seqstring *s,int i,int j)/*串的删除*/
{ int k;
printf("请输入原字符串和其长度:");
scanf("%s%d",s,&s->curlen); for(k=i+j-1;s->ch[k]!='\0';k++) s->ch[k-j]=s->ch[k]; s->ch[k-j]='\0'; s->curlen=k-j;
第二章:课程设计内容.........................................................................................................1 2.1 程序设计代码:.........................................................................................................1 2.2:程序设计的基本思想:......................................................................................12 2.3 程序运行结果:....................................................................................................15
数据结构串的应用及实现报告
实习报告课程名称: 数据结构实验名称: 串及其应用指导教师:学生班级:学生姓名:学生学号:完成日期:一、 需求分析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的子串,并返回产生的新串。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
第四章字符串的应用【实验目的】1. 熟练掌握字符串的数据类型定义以及字符串的五种基本操作的定义,并能利用这些基本操作实现字符串的其他基本操作的方法。
2. 熟练掌握字符串串的定长顺序存储结构上实现字符串的各种操作的方法。
3. 理解字符串的堆分配存储表示以及在其上实现字符串操作的基本方法。
4. 熟练掌握串的基本操作类型的实现方法,其中文本模式匹配方法是一个难点,在掌握了BF算法的基础上理解改进的KMP算法。
5. 了解一般文字处理软件的设计方法。
第一节知识准备一、有关串几个重要概念1. 串(字符串):零个或多个字符组成的有限序列。
一般记作s="a1a2 …an"(n≥0)2. 长度:串中字符的数目3. 空串:零个字符的串,其长度为零4. 子串和主串:串中任意个连续的字符组成的子序列称为该串的子串;包含子串的串相应地称为主串,字符在序列中的序号为该字符在串中的位置。
5. 当两个串的长度相等,并且各个对应位置的字符都相等时称为两串相等。
6. 空格串:由一个或多个空格组成的串‘’,同空串是完全不同的。
二、串的抽象数据类型定义ADT String{数据对象:D={ | ∈C haracterSet, i=1,2,...,n, n>=0}数据关系:R1={< , >| , ∈D,i=2,...,n}基本操作:Assign(&s,t) 将串t的值赋给串sCreate(&s,ss) 将串s的值设定为字符序列ssEqual(s,t) 判定串s和串t是否相等Length(s) 求串s的长度Concat(&s,t) 将串s和串t连接成一个串,结果存于s中Substr(&sub,s,start,len) 从s的第start个字符起,取长为len的子串存于subIndex(s,t) 求子串t在主串s中第一次出现的位置Replace(&s,t,v) 以串v替换串s中的所有的非空子串tInsert(&s,pos,t) 在串s的第pos个字符之前插入串t;Delete(&s,pos,len) 从串s中删去从第pos个字符起长度为len的子串;} ADT String三、串的存储结构1. 定长顺序存储表示用一组地址连续的存储单元来存放字符序列,并约定该结构能存放字符的个数。
#define MAXLEN 字符最大个数typedef struct{int len;char ch[MAXLEN];} SString;2. 堆分配存储表示系统先分配一个容量很大的地址连续的存储空间作为字符串的存放空间,每建立一个新串,系统从该空间中分配一个大小和串长相同的空间来存放新串。
typedef Struct{ char *ch ; //存储空间基址int length; //串的长度}Hstring;3. 串的块链存储表示用链表形式来存储串,如果以串中每一个字符作为一个结点,使得相应的存储占用量增大,因此可采用将多个字符作为一个结点的形式来形成链表(即块链形式)#define MAX 80 //用户定义块的大小typedef struct str{char ch[MAX];struct str *next;typedef struct string{ Chunk *head,*tail;int length;}LString在串的处理操作中,我们可视不同的情况进行选择使用不同的定义形式,当对字符串进行连接,删除等操作时,采用链结构更为方便上些,但采用链结构在进行串的截取(求子串)等操作时则比采用静态结构效率更低。
第二节串的基本操作示例【问题描述】用C语言实现串的一些基本操作算法。
【数据描述】采用静态存储结构来表示串,用一维字符数组来存放字符序列,用整数len来表示当前串实际长度。
#define STRINGMAX 81 //串最多存放字符的个数struct string{int len;char ch[STRINGMAX];};typedef struct string STRING;【C源程序】本程序只设计了串的创建,联接,求子串和删除操作,其余各基本操作可在本程序基础上进行改进,补充。
#include "stdlib.h"#include "stdio.h"#define STRINGMAX 81#define LEN sizeof(struct string)/* 串的定义*/struct string{int len;char ch[STRINGMAX];};typedef struct string STRING;void creat(STRING *s);void print(STRING *s);void concat(STRING *s,STRING *t);STRING *substr(STRING *s,int start,int len);void delete(STRING *s,int start,int len);main(){STRING *s,*t,*v; /*定义三个采用静态存储形式的串*/int start,len;int position;t=(STRING *)malloc(LEN); /*为三个串分配相应的存储空间*/s=(STRING *)malloc(LEN);v=(STRING *)malloc(LEN);printf("please input the string s:"); /*创建S串*/creat(s);printf("please input the string t:"); /*创建T串*/creat(t);concat(s,t); /* 连接并输出相应的串*/printf("the new string s :");print(s);printf("plese input the start position:");/*输入截取子串的起始位置*/scanf("%d",&start);printf("please input the length:"); /*输入截取子串的长度*/ scanf("%d",&len);v=substr(s,start,len); /*截取子串*/printf(“the substring :”);print(v);printf("plese input the start position:"); /* 输入删除串的起始位置*/ scanf("%d",&start);printf("please input the length:"); /* 输入删除串的长度*/delete(s,start,len); /*删除串*/printf("the deleted string s :");print(s);}void delete(STRING *s,int start,int len){int i;if (start<=s->len&&len>=0&&start+len<=s->len)/*删除操作合法性验证*/ {for(i=start+len;i<=s->len;i++) /*从start位置开始移动元素*/s->ch[i-len]=s->ch[i];s->len=s->len-len; /*置新的长度*/}elseprintf("cannot delete!\n");}STRING *substr(STRING *s,int start,int len){int i;STRING *t;t=(STRING *)malloc(LEN);if (start<0&&start>=s->len) /*取子串的合法性验证*/return(NULL);elseif (len>=1&&len<=s->len-start){ for(i=0;i<len;i++) /*取字符序列入到子串的字符数组中*/ t->ch[i]=s->ch[start+i];t->len=len; /*置子串长度*/t->ch[i]='\0';return(t);}return(NULL);}void concat(STRING *s,STRING *t){int i,j;if (s->len+t->len>(STRINGMAX-1)) /*连接操作合法性验证*/printf("too long!cannot concat!!");else{j=s->len;for (i=0;i<t->len;i++)s->ch[i+j]=t->ch[i]; /*将串t中字符序列放入串s的尾部*/ s->ch[i+j]= '\0 ';s->len=s->len+t->len; /*置新串s的长度*/}}void creat(STRING *s){char c;int i;for (i=0;((c=getchar())!='\n '&&i<80);i++)s->ch[i]=c; /*将输入的字符序列放入串的字符数组中*/ s->len=i; /*置串的长度*/s->ch[i]= '\0 ';}void print(STRING s) /*输出串的字符序列*/{int i;for (i=0;s->ch[i]!= '\0 ';i++)printf("%c",s->ch[i]);printf("\n");}please input the string s:abcd↙please input the string t:efg↙the new string s:abcdefg↙plese input the start position:3↙please input the length:3↙the substring:def↙plese input the start position:3↙please input the length:3↙the deleted string s :abcg↙【分析说明】1. 上述程序采用的是串的静态存储形式,在定义串时对串可能容纳的字符个数要正确估计,否则会造成存储空间的大量浪费;2. 在进行串的连接操作时,还必须考虑连接后形成的新串长度是否会大于串定义的最大长度;采用链式存储形式可以解决上述问题。