实验报告-串的基本操作

合集下载

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

实验三串基本操作的编程实现(共5页)--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--实验三串基本操作的编程实现【实验目的】内容：串基本操作的编程实现要求：串基本操作的编程实现（2学时，验证型），掌握串的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、合并、剪裁等操作，存储结构可以在顺序结构或链接结构、索引结构中任选，也可以全部实现。

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

【实验性质】验证性实验（学时数：2H）【实验内容】字符串用常规的顺序存储法来存储，实现常用的功能。

自己编程模式：开发一个程序，用来统计文件中各种信息，如字符个数，行数等。

修改程序模式：将下面程序空白的地方填空。

程序检查模式：将本文件夹中的程序运行后总结相关功能。

【思考问题】1.字符串的顺序存储和链表存储的差异C语言中是如何实现字符串的2.在字符串处理方面主要有什么操作3.字符串的操作的主要特点是什么4.举出几个字符串的应用范例【参考代码】立顺序串（仅限单行的字符串，建议不用汉字。

）"<<endl;cout<<"2.显示串"<<endl;cout<<"3.修改串"<<endl;cout<<"4.插入串"<<endl;cout<<"5.删除串"<<endl;cout<<"6.查找串"<<endl;cout<<"7.求串长度"<<endl;cout<<"8.结束程序"<<endl;cout<<"=========="<<endl;}int main(){int flag=0,returnvalue,position,beginposition,endposition,length;char choice,choose,newstr[maxsize];string newstring;menu();while(1){cout<<"请输入选择:";cin>>choice;switch(choice){case '1':if(flag){cout<<"数据已存在，是否覆盖(y/n)";cin>>choose;if(choose=='N'||choose=='n'){cout<<"数据没有发生更改!"<<endl;break;}if(choose=='Y'||choose=='y'){returnvalue=();if(returnvalue==success)cout<<"创建成功!"<<endl;flag=1;}elsecout<<"输入错误!"<<endl;}else{returnvalue=();if(returnvalue==success)cout<<"创建成功!"<<endl;flag=1;}break;case '2':if(flag==0)cout<<"请先建立串!"<<endl;else();break;case '3':if(flag==0)cout<<"请先建立串!"<<endl;else{();cout<<"请输入要修改的初始位置:";cin>>beginposition;cout<<"请输入要修改的终止位置:";cin>>endposition;cout<<"请输入修改后的字符串:";cin>>newstr;returnvalue=(beginposition,endposition,newstr);if(returnvalue==success){cout<<"修改成功!"<<endl;();}if(returnvalue==overflow){cout<<"字符串的最大长度为"<<maxsize<<endl;cout<<"发生溢出，操作失败!"<<endl;}if(returnvalue==range_error)cout<<"位置错误,操作失败!"<<endl;if(returnvalue==empty)cout<<"字符串为空,操作失败!"<<endl;}break;case '4':if(flag==0)cout<<"请先建立串!"<<endl;else{();cout<<"请输入要插入的位置:";cin>>position;cout<<"请输入要插入的字符串:";cin>>newstr;length=strlen(newstr);returnvalue=(position,newstr,length);if(returnvalue==success){cout<<"插入成功!"<<endl;();}if(returnvalue==overflow){cout<<"字符串的最大长度为"<<maxsize<<endl;cout<<"发生溢出，操作失败!"<<endl;}if(returnvalue==range_error)cout<<"位置错误，操作失败!"<<endl;}break;case '5':if(flag==0)cout<<"请先建立串!"<<endl;else{();cout<<"请输入要删除的初始位置:";cin>>beginposition;cout<<"请输入要删除的终止位置:";cin>>endposition;returnvalue=(beginposition,endposition);if(returnvalue==success){cout<<"删除成功!"<<endl;();}if(returnvalue==range_error)cout<<"位置错误，操作失败!"<<endl;if(returnvalue==empty)cout<<"字符串为空,操作失败!"<<endl;}break;case '6':if(flag==0)cout<<"请先建立串!"<<endl;else{();cout<<"请输入要查找的字符串:";cin>>newstr;position=(newstr);if(position>0){cout<<"已找到!"<<endl;cout<<"字符串出现的初始位置为:"<<position<<endl;}if(position==0)cout<<"您要查找的字符串不存在!"<<endl;if(position==-1)cout<<"字符串为空,操作失败!"<<endl;}break;case '7':if(flag==0)cout<<"请先建立串!"<<endl;else{();length=();cout<<"当前串的长度为:"<<length<<endl;}break;case '8':exit(0);break;default:cout<<"输入错误!\n";break;}cout<<"按任意键继续......"<<endl;getch();system("cls");menu();}getch();return 0; }。

烧烤制作实验报告

一、实验目的1. 掌握烧烤的基本技巧和操作流程。

2. 了解烧烤食材的选择和处理方法。

3. 探索不同烧烤调料的使用效果。

4. 培养团队协作和动手能力。

二、实验时间2021年X月X日三、实验地点校园内烧烤区四、实验材料1. 烧烤食材：鸡翅、羊肉串、烤肠、蔬菜串等。

2. 烧烤工具：烧烤架、烧烤夹、炭火、烤网等。

3. 烧烤调料：孜然粉、辣椒粉、生抽、老抽、料酒、蜂蜜等。

五、实验步骤1. 食材准备（1）鸡翅：将鸡翅清洗干净，用料酒、生抽、老抽腌制20分钟。

（2）羊肉串：将羊肉切成小块，用料酒、生抽、老抽腌制20分钟。

（3）烤肠：将烤肠清洗干净，切成适当长度。

（4）蔬菜串：将蔬菜洗净，切成小块，用料酒、生抽、老抽腌制10分钟。

2. 烧烤调料准备（1）孜然粉：取适量孜然粉备用。

（2）辣椒粉：取适量辣椒粉备用。

（3）蜂蜜：取适量蜂蜜备用。

3. 烧烤操作（1）点燃炭火，待炭火烧至红热时，将烧烤架放置在炭火上。

（2）将腌制好的食材依次夹在烧烤夹上，放入烧烤架。

（3）根据食材的不同，调整烧烤时间。

例如，鸡翅烤制时间为8-10分钟，羊肉串烤制时间为5-7分钟，烤肠烤制时间为3-5分钟，蔬菜串烤制时间为2-3分钟。

（4）在食材烤制过程中，适时翻转，使食材受热均匀。

（5）根据个人口味，适量撒上孜然粉、辣椒粉和蜂蜜。

（6）烤制完成后，将食材夹出，放在盘中。

六、实验结果与分析1. 实验结果通过本次实验，我们成功制作了鸡翅、羊肉串、烤肠、蔬菜串等烧烤食材。

在烤制过程中，食材受热均匀，口感鲜美，色香味俱佳。

2. 结果分析（1）食材腌制：腌制食材可以增加食材的口感和风味，使烧烤更加美味。

（2）烧烤时间：根据食材的不同，调整烧烤时间，使食材烤制均匀。

（3）烧烤调料：适当添加孜然粉、辣椒粉和蜂蜜，可以增加烧烤的口感和风味。

（4）团队协作：在实验过程中，团队成员分工明确，相互配合，共同完成了烧烤制作。

七、实验总结通过本次烧烤制作实验，我们掌握了烧烤的基本技巧和操作流程，了解了烧烤食材的选择和处理方法，探索了不同烧烤调料的使用效果。

c语言描述-串的基本操作

c语⾔描述-串的基本操作串的定长顺序存储（部分代码）连接两个串：串的第⼀个空间存储串长#define MIXSIZE 100typedef int Status;typedef char SString[MIXSIZE+1];Status Concat(SString *s3,SString s1,SString s2){if(s1[0]+s2[0]<=MIXSIZE){printf("fgsd\n");for(int i=1;i<=s1[0];i++){*s3[i]=s1[i];}for(int i=s1[0]+1;i<s1[0]+s2[0];i++){*s3[i]=s2[0];}*s3[0]=s1[0]+s2[0];return TRUE；}else if(s1[0]<MIXSIZE&&(s1[0]+s2[0]>MIXSIZE)){printf("fgsd\n");for(int i=1;i<=s1[0];i++){*s3[i]=s1[i];}for(int i=s1[0]+1,j=1;(void)(i<=MIXSIZE),j<=MIXSIZE-s1[0];j++,i++){*s3[i]=s2[j];}*s3[0]=MIXSIZE;return FALSE；}else{for(int i=1;i<=MIXSIZE;i++){*s3[i]=s1[i];}*s3[0]=MIXSIZE;return FALSE;}}求⼦串：void SubString(SString *s3,SString s1,int pos,int len){if(pos<1||len>s1[0]||len<0||len>s1[0]-pos+1)printf("⾮法操作！\n");for(int i=1,j=pos;(void)(i<len),j<pos+len-1;i++,j++){*s3[i]=s1[j];}*s3[0]=len;}串的堆分配存储表⽰#include<stdio.h>#include <stdlib.h>#include<string.h>typedef struct{char *ch;int length;}HString;//将字符串chars复制到字符串T中void StrAssign(HString *T,char *chars){int len = 0;while(*(chars+len)!='\0') //计算串的长度{len++;}if(len==0) //串chars为空的情况{T->ch=NULL;T->length=0;}else{T->ch=(char *)malloc(len * sizeof(char));for(int i=0;i<len;i++){T->ch[i]=*(chars+i);}T->length=len;}}//打印串T元素void Print_str(HString *T ){int i=0;while(i<T->length){printf("%c",T->ch[i++]);}printf("\n");}//返回串长度int StrLength(HString *T){return T->length;}//⽐较两串int StrCompare(HString *T,HString *S ){int i;if(T->length!=S->length){if(T->length>S->length){printf("字符串不等，s1的长度⼤于s2\n");return 1;}else{printf("字符串不等，s1的长度⼩于s2\n");return -1;}}else{for(i=0;i<T->length;i++){if(T->ch[i]>S->ch[i]){printf("长度相等，但s1>s2\n");return 1;}else if(T->ch[i]<S->ch[i]){printf("长度相等，但s1>s2\n");return -1;}}printf("字符串相等\n");return 0;}}//连接两的字符串void Concat(HString *T,HString *s1,HString *s2){T->ch=(char *)malloc((s1->length+s2->length)*sizeof(char)); if(!T->ch)exit(0);for(int i=0;i<s1->length;i++)T->ch[i]=s1->ch[i];}for(int i=s1->length,j=0;i<s1->length+s2->length;i++,j++) {T->ch[i]=s2->ch[j];}T->length=s1->length+s2->length;}//求⼦串void SubString(HString *T,HString *S,int pos,int len){T->ch=(char *)malloc(len*sizeof(char));if(!T->ch)exit(0);for(int i=pos-1,j=0;i<pos+len;i++,j++){T->ch[j]=S->ch[i];}T->length=len;}//清空串void ClearString(HString *T ){if(T->ch){free(T->ch);T->ch=NULL;}T->length=0;}//主函数，可对函数进⾏测试int main(){char s1[100];char s2[100];printf(" 请输⼊字符串s1:\n");gets(s1);printf("请输⼊字符串s2:\n");gets(s2);HString S,S1,S2,*p,*p1,*p2;p=&S; p1=&S1; p2=&S2;StrAssign(p1, s1);//StrAssign(p2, s2);//StrCompare(p1, p2);//Concat(p, p1, p2);//SubString(p, p1, 2, 4);//Print_str(p1);//ClearString(p1);//Print_str(p1);}串的模式匹配算法1、传统算法int Index(HString *T,HString *S, int pos){int j=0;while(pos<T->length&&j<S->length){if(T->ch[pos]==S->ch[j]){pos++;j++;}else{pos=pos-j+2;j=1;}}if(j>=S->length){int len;len=pos-S->length+1;printf("%d",len);return len;}else{return 0;}。

串-数据结构实验报告

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

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

二、实验环境本次实验使用的编程语言为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、连接操作成功实现，输出了正确连接后的字符串。

串联并联创新实验报告(3篇)

第1篇一、实验目的1. 理解串联和并联电路的基本原理。

2. 掌握串联和并联电路的连接方法。

3. 通过实验验证串联和并联电路的电压、电流分配规律。

4. 培养创新思维，提高实验操作能力。

二、实验原理串联电路：将多个电阻依次连接起来，形成一个单一的电路。

在串联电路中，电流在各个电阻上保持不变，而电压则按照电阻值成比例分配。

并联电路：将多个电阻分别连接在两个节点之间，形成一个分支电路。

在并联电路中，电压在各个电阻上保持不变，而电流则按照电阻值的倒数成比例分配。

三、实验器材1. 电源：直流电源，电压可调。

2. 电阻：不同阻值电阻若干。

3. 电表：电流表、电压表。

4. 导线：若干。

5. 连接器：若干。

四、实验步骤1. 串联电路连接（1）将电阻依次连接起来，形成一个串联电路。

（2）将电流表串联接入电路中，测量电路中的电流。

（3）将电压表分别接入各个电阻上，测量各个电阻上的电压。

（4）记录实验数据。

2. 并联电路连接（1）将电阻分别连接在两个节点之间，形成一个并联电路。

（2）将电流表分别接入各个电阻的支路中，测量各个电阻上的电流。

（3）将电压表接入电路的两个节点之间，测量电路中的电压。

（4）记录实验数据。

3. 数据分析（1）对比串联和并联电路中的电流、电压分配规律。

（2）分析实验数据，得出结论。

五、实验结果与分析1. 串联电路实验结果（1）电流表测量到的电流在各个电阻上保持不变。

（2）电压表测量到的电压按照电阻值成比例分配。

2. 并联电路实验结果（1）电流表测量到的电流按照电阻值的倒数成比例分配。

（2）电压表测量到的电压在各个电阻上保持不变。

3. 分析通过实验验证了串联和并联电路的电压、电流分配规律，进一步理解了电路的基本原理。

同时，实验过程中培养了创新思维，提高了实验操作能力。

六、实验结论1. 串联电路中，电流在各个电阻上保持不变，电压按照电阻值成比例分配。

2. 并联电路中，电压在各个电阻上保持不变，电流按照电阻值的倒数成比例分配。

串的基本操作

串得基本操作一、实验目得、意义(１)理解串得堆分配存储结构。

(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)。

串的存储实验报告(3篇)

第1篇一、实验目的1. 理解串的概念及其在计算机中的应用。

2. 掌握串的存储方式及其在C语言中的实现。

3. 熟悉串的基本操作，如串的创建、串的复制、串的连接等。

4. 通过实验验证串操作的准确性和效率。

二、实验原理1. 串（String）是由零个或多个字符组成的有限序列，是计算机中常用的非数值数据类型。

2. 串的存储方式主要有两种：顺序存储和链式存储。

3. 顺序存储是将串的字符序列存储在一段连续的内存空间中，通过数组来实现。

4. 链式存储则是通过链表来实现，每个节点存储一个字符，节点之间通过指针连接。

三、实验环境1. 操作系统：Windows 102. 编程语言：C3. 编译器：Visual Studio 2019四、实验内容1. 创建一个串，并对其进行初始化。

2. 复制一个串，并验证复制的串与原串内容相同。

3. 连接两个串，并验证连接后的串内容。

4. 实现串的插入、删除、查找等操作。

5. 对串进行排序，如按字典序排序。

五、实验步骤1. 创建一个串```cinclude <stdio.h>include <stdlib.h>include <string.h>define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int length;} String;// 创建串String createString(const char str) { String s;strcpy(s.data, str);s.length = strlen(str);return s;}```2. 复制一个串```c// 复制串String copyString(const String s) { String t;strcpy(t.data, s.data);t.length = s.length;return t;}```3. 连接两个串```c// 连接两个串String concatString(const String s1, const String s2) { String s;strcpy(s.data, s1.data);strcat(s.data, s2.data);s.length = s1.length + s2.length;return s;}```4. 实现串的插入、删除、查找等操作```c// 插入字符void insertChar(String s, int pos, char ch) {if (pos < 0 || pos > s->length) {printf("Insert position is invalid.\n");return;}for (int i = s->length; i >= pos; i--) {s->data[i + 1] = s->data[i];}s->data[pos] = ch;s->length++;}// 删除字符void deleteChar(String s, int pos) {if (pos < 0 || pos >= s->length) {printf("Delete position is invalid.\n"); return;}for (int i = pos; i < s->length - 1; i++) { s->data[i] = s->data[i + 1];}s->length--;}// 查找字符int findChar(const String s, char ch) {for (int i = 0; i < s.length; i++) {if (s.data[i] == ch) {return i;}}return -1;}```5. 对串进行排序```c// 字典序排序void sortString(String s) {for (int i = 0; i < s->length - 1; i++) {for (int j = i + 1; j < s->length; j++) {if (s->data[i] > s->data[j]) {char temp = s->data[i];s->data[i] = s->data[j];s->data[j] = temp;}}}}```六、实验结果与分析1. 创建串、复制串、连接串等操作均能正常进行，验证了串的存储和操作的正确性。

串操作实验报告

竭诚为您提供优质文档/双击可除串操作实验报告篇一：顺序串的基本操作实验报告宁波工程学院电信学院计算机教研室实验报告课程名称：数据结构实验项目：顺序串的基本操作实验人员：徐浩学号：10401010209班级：计科102指导教师：宋宏图实验位置：计算机中心二楼实验日期：20XX-10-13一、实验目的1）熟悉串的定义和串的基本操作。

2）掌握顺序串的基本运算。

3）加深对串数据结构的理解，逐步培养解决实际问题的编程能力。

二、实验环境装有Visualc＋＋6.0的计算机。

本次实验共计2学时。

三、实验内容编写一个程序，实现顺序串的各种基本运算，并在此基础上设计一个主程序。

具体如下：编写栈的基本操作函数顺序串类型定义如下所示：typedefstruct{charch[mAxsIZe];intlen;}seqstring;（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的子串,并返回产生的新串。

（9）串替换Repstr(s,s1,s2)?在串s中,将所有出现的子串s1均替换成s2。

（10）输出串Dispstr(s)?输出串s的所有元素值（11）判断串是否为空Isempty(s)编写主函数调用上述函数实现下列操作：（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是否相等，输出结果程序：#include#definemAxsIZe100typedefstruct{charch[mAxsIZe];intlen;}sqstring;voidstrAssign(sqstringfor(i=0;t[i]!=\0;i++)s.ch[i]=t[i];s.len=i;}voidstrcopy(sqstring并输出for(i=0;i s.ch[i]=t.ch[i];s.len=t.len;}voidstrequal(sqstrings,sqstringt){//判断串相等intsame=1,i;if(s.len!=t.len){same=0;}else{for(i=0;i if(s.ch[i]!=t.ch[i]){same=0;break;}}if(same==0)printf("s1,s5不相等");elseprintf("s1,s5相等");printf("\n");}voidstrLength(sqstrings){//计算串长度printf("t1的长度：");printf("%d",s.len);printf("\n");}sqstringconcat(sqstrings,sqstringt){//串连接sqstringstr;inti;str.len=s.len+t.len;for(i=0;i str.ch[i]=s.ch[i];for(i=0;i str.ch[s.len+i]=t.ch[i];returnstr;}sqstringsubstr(sqstrings,inti,intj){//求子串sqstringstr;intk;str.len=0;if(is.len||js.len)returnstr;for(k=i-1;k str.ch[k-i+1]=s.ch[k];str.len=j;returnstr;}sqstringInsstr(sqstrings1,inti,sqstrings2){//插入intj;sqstringstr;str.len=0;if(is1.len+1)returnstr;for(j=0;j str.ch[j]=s1.ch[j];for(j=0;j str.ch[i+j-1]=s2.ch[j];for(j=i-1;j str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;returnstr;}sqstringDelstr(sqstrings,inti,intj){//删除intk;sqstringstr;str.len=0;if(is.len||i+j>s.len+1)returnstr;for(k=0;k str.ch[k]=s.ch[k];for(k=i+j-1;k str.ch[k-j]=s.ch[k];str.len=s.len-j;returnstr;sqstringRepstr(sqstrings,inti,intj,sqstringt){//替换intk;sqstringstr;str.len=0;if(is.len||i+j-1>s.len)returnstr;for(k=0;k str.ch[k]=s.ch[k];for(k=0;k str.ch[i+k-1]=t.ch[k];for(k=i+j-1;k str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;returnstr;}voidDispstr(sqstrings){//输出串所有元素inti;if(s.len>0){for(i=0;i printf("%c",s.ch[i]);printf("\n");}}voidIsempty(sqstrings){//判断串是否为空if(s.len>0)printf("串不为空");elseprintf("串为空");printf("\n");}篇二：串实验报告篇三：字符串实验报告数据结构字符串实验班级：计算机应用技术10-1学号：10602101048姓名：姚福刚一、实验目的及要求：掌握有关字符串的基本操作和存储结构，并编写相应的基本操作算法。

_串的基本操作

实验三串的基本操作【实验内容与要求】问题描述：采用顺序存储结构，完成串的联接和子串定位操作。

基本要求：（1）定义串的顺序存取结构。

（2）分别定义串的联接和子串定位的基本操作。

（3）设计一个测试主函数进行测试。

【测试数据】有两个串，分别为s1=‘ababbaabaa’，s2=‘aab’。

输出串s1与串s2联接的结果，以及在串s1中对串s2定位的结果。

二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）1）符号名说明s1，s2 分别定义为母串和字串的字符数组x，y 分别定义为全局变量，用来表示2个串的长度s3 表示连接完成的字符串k 表示定位的结果2）程序流程图三、源程序及注释：#include"stdio.h"#include"string.h"int x,y;int dingwei(char s1[],char s2[])；定位函数{ int i,j,k;i=0;j=0;while(i<x&&j<y)；i，j分别来控制s1，s2数组中字符的位置{if(s1[i]==s2[j])如果二者相等，则比较2个数组的下一位{i++;j++;}else {i=i-j+1;j=0; }；不相等j置数为0，i从i-j+1开始}if(s2[y-1]==s1[i-1]&&j==y) return i-j+1; 比较完后，输出比较结果else return 0;}int lianjie(char s1[],char s2[]){ int i,j,k;char s3[50];；定义一个数组来存放s1，s2连接后的字符串i=0;j=0;while(s1[i]!=0){ s3[i]=s1[i];i++; ；依次将s1中的字符串输入到s3中}while(s2[j]!=0){s3[i]=s2[j];将s2中的字符串紧接着传送到s3中i++;j++;}s3[i]=0;puts(s3);输出连接完成后的结果}int main(){char s1[50],s2[50];int i,j,k;printf("\t\t串的基本操作");printf("\n\t输入主字符串：");gets(s1);输入语句x=strlen(s1);计算s1的长度printf("\n\t输入子字符串：");gets(s2);y=strlen(s2);k=dingwei(s1,s2);调用定位函数printf("\n\t定位结果：");；输出定位结果if(k) printf("\t%d",k);else printf("不存在从属关系");printf("\n\t字符串相连：");lianjie(s1,s2);调用连接函数，将字符串连接getchar();}四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：这个程序要实现的要求相对而言是比较容易实现的；只要知道关于字符数组的一些基本操作指令，再结合for语句循环，应该能实现题目所要求的条件。

串的基本操作

串的基本操作#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef struct{char *str;int length;}HString;//堆串//初始化void InitString(HString &S){S.str ='\0';S.length =0;}//堆串赋值void StrAssign(HString &S,char *chars) {int i,len;char *p;p=chars;if(S.length ==0) return 1;else return 0;}//求堆串长度int StrLength(HString S){r eturn S.length ;}//串的复制操作int StrCopy(HString &T,HString S)/*将串S复制给串T*/{int i;T.str =(char *)malloc(S.length*sizeof(char));if(!T.str)return 0;for(i=0;i<S.length;i++)T.str[i]=S.str[i];T.length=S.length;return 1;}//串的比较操作int StrCompare(HString S,HString T)/*比较串S与串T的大小，如果S的值大于T，返回正值；如果S的值小于T，返回负值；如果相等，返回0*/{int i;for(i=0;i<S.length&&i<T.length;i++)if(S.str[i]!=T.str[i])return (S.str[i]-T.str[i]);return (S.length-T.length );}//串的插入操作int StrInsert(HString &S,int pos,HString T) /*在S中第pos个位置插入T*/{int i;if(pos<0||pos-1>S.length){printf("插入位置错误\n");return 0;}S.str=(char*)realloc(S.str,(S.length+T.length)*sizeof(char) );if(!S.str){printf("内存分配失败\n");return 0;}for(i=S.length-1;i>pos-1;i--)S.str[i+T.length]=S.str[i];for(i=0;i<T.length;i++)S.str[pos+i-1]=T.str[i];S.length=S.length+T.length;return 1;}//串的删除操作int StrDelete(HString &S,int pos,int len)/*在S中删除pos开始的len个字符*/{i nt i;c har *p;i f(pos<0||pos+len-1>S.length){printf("删除位置错误，参数len不合法\n");return 0;}p=(char *)malloc(S.length-len);if(!p){printf("内存分配失败\n");return 0;}for(i=0;i<pos-1;i++)p[i]=S.str[i];for(i=pos-1;i<S.length-len;i++)p[i]=S.str[i+len];S.length=S.length-len;free(S.str);S.str=p;return 1;}//串的连接操作int StrConcat(HString &T,HString S)/*将串S连接在T后*/{int i;T.str=(char*)realloc(T.str,(T.length+S.length)*sizeof(char) ) ;if(!T.str){printf("内存分配失败\n");return 0;}else{for(i=T.length;i<T.length+S.length ;i++)T.str[i]=S.str[i-T.length];T.length =T.length +S.length ;}return 1;}//截取子串操作int SubString(HString &Sub,HString S,int pos,int len)/*将从S中第pos个位置截取长度为len 的子串赋值给Sub*/{int i;if(Sub.str ) free(Sub.str );if(pos<0||len<0||pos+len-1>S.length ){printf("参数len和pos不合法\n");return 0;}else{Sub.str =(char *)malloc(len*sizeof(char));if(!Sub.str){printf("内存分配失败\n");return 0;}for(i=0;i<len;i++)Sub.str[i]=S.str[pos+1-1];Sub.length =len;return 1;}}//串的定位操作int StrIndex(HString S,int pos,HString T)/*在主串S中的第pos个位置开始查找子串T，如果找到，返回子串在主串中的位置；否则，返回-1*/{int i,j;if(StrEmpty(T)){printf("子串为空\n");return 0;}i=pos-1;j=0;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)return i-j+1;elsereturn -1;}//串的替换操作int StrReplace(HString &S,HString T,HString V)/*将串S中的所有子串T用V替换*/{i nt i=1;i nt flag;i f(StrEmpty(T)){printf("子串为空\n");return 0;}do{i=StrIndex(S,i,T);if(i){StrDelete(S,i,StrLength(T));flag=StrInsert(S,i,V);if(!flag){printf("插入失败\n");return 0;}i+=StrLength(V);}}while(i);return 1;}//串的清空操作void StrClear(HString &S) {if(S.str ) free(S.str);S.str='\0';S.length=0;}//输出串void Strprint(HString S){int i;for(i=0;i<S.length ;i++)printf("%c",S.str[i]);}int scan(){int d;printf("\n\n请输入要进行的操作\n1.初始化一个串S\n2.清空串\n3.求串长度\n4.检查串是否为空\n5.输出串\n6.串的赋值操作\n7.串的复制操作\n8.串的比较操作\n9.串的插入操作\n10.串的删除操作\n11.串的连接操作\n12.截取子串操作\n13.串的替换操作\n14.串的定位操作\n其他键退出...\n");scanf("%d",&d);return (d);}main(){int quit =0,pos,len;char a[200];char *s=a;HString S,T,V,Sub;while(!quit)switch(scan()){case 1:InitString(S);break;case 2:StrClear(S);break;case 3:printf("串的长度为:%d\n",StrLength(S));break;case 4:if(StrEmpty(S)) printf("串为空\n");else printf("串非空\n");break;case 5:Strprint(S);break;case 6:printf("请输入要给串S赋的值：");scanf("%s",s);StrAssign(S,s);break;case 7:printf("将串T复制给串S\n");printf("请输入串T的值：");scanf("%s",s);InitString(T);StrAssign(T,s);if(StrCopy(S,T) )printf("复制成功。

串及其应用的实验报告

一、实验目的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三.实验结论及分析串的存储结构包含有顺序存储结构和链式存储结构。

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

串的基本操作

一．实验目的如果计算机语言没有把串作为一个预先定义好的基本类型对待，又需要用该语言写一个涉及串操作的软件系统时，用户必须自己实现串类型。

试着实现串类型，并写一个串的基本操作演示系统。

二．实验内容实现若干串的常用基本操作，如串赋值、求串长、串替换、串比较、求子串及串的模式匹配等。

模块设计本程序包含两个模块：主程序模块、串操作模块。

其调用关系如图2所示。

图2 模块调用关系示意图三．实验步骤（可选）数据类型定义(1) 字符串的定义typedef struct{char *ch; //串存放的数组int curLen; //串的长度}HString;(2) 全局变量声明#define OK 1 //操作成功#define OVERFLOW 0 //溢出#define ERROR 0 //出错系统主要子程序详细设计(1)主程序模块设计主函数。

设定用户操作界面，调用操作模块函数。

void main(){输出操作菜单；Switch (1){输出操作序号c；switch (c){调用相应函数执行相应操作；输出操作结果；}}}(2)求子串int substring(HString &Sub,HString S,int pos,int len){ //´串sub返回串S的第pos个字符起长度为len的子串int i;if(pos<0||pos>S.curLen||len<0||len>S.curLen-pos){ //若位置或长度不合法，退出printf("输入不合法\n");exit(OVERFLOW); //退出}else{if(Sub.ch) free(Sub.ch); //释放子串sub原有空间if(!len) //若长度len为0{ //就爱那个子串置为空串Sub.ch=NULL;Sub.curLen=0;}else //若长度len不为0{Sub.ch=(char*)malloc(len*sizeof(char));for(i=0; i<len; i++){ //从串S的第pos个字符开始依次复制其后长度为len的字符串sub中Sub.ch[i]=S.ch[pos-1+i];Sub.curLen=len; //修改串sub的串长}}return OK;}}(3)子串定位（串的模式匹配）int Index(HString &ob1,HString &ob2,int pos){ //判断从第pos个字符起，ob2是否为ob1的子串//若是返回ob2在ob1中的起始位置，否则返回-1if(pos<0||pos>ob1.curLen){//若输入的数值pos不在ob1的串长范围内printf("输入有误\n");exit(ERROR);}for(int i=pos-1; i<=StrLength(ob1)-StrLength(ob2); i++){ //从ob1的第pos个字符起查找子串ob2int j=0; //从ob2的第一个字符起开始查找while(j<StrLength(ob2)) //j控制查找位置，逐个字符查找，直到超出子串串长{if(ob1.ch[i+j]==ob2.ch[j]) //若找到匹配字符j++; //则依次向后查找else break; //一旦失配，则跳出查找，此时j还未能达到子串串长}if(j==StrLength(ob2)) //若j达到子串串长，即ob2的所有字符都能和ob1匹配return i; //返回ob2在ob1的起始位置i}return -1; //ob2不是ob1的子串，返回-1}(4)串替换void Replace(HString &ob1,HString &ob2,HString &ob3){ //将原串ob1的所有子串ob2都替换为插入串ob3printf("原串：");for(int i=0; i<ob1.curLen; i++)printf("%c",ob1.ch[i]);printf("\n 子串：");for(int j=0; j<ob2.curLen; j++)printf("%c",ob2.ch[j]);printf("\n");printf("插入串：");for(int k=0; k<ob3.curLen; k++)printf("%c",ob3.ch[k]);printf("\n");int len=StrLength(ob2); //ob2的长度while(Index(ob1,ob2,0)!=-1) //当ob2是ob1的子串，替换所有的ob2 {int len2=StrLength(ob3)+StrLength(ob1)-StrLength(ob2); //新串的长度int i=Index(ob1,ob2,0); //调用子串定位函数char *p=new char[StrLength(ob1)-i-len+1]; //临时数组char *q=new char[len2]; //存储新串的数组for(int j=i+len; j<StrLength(ob1); j++)p[j]=ob1.ch[j]; //将不用替换的后部分存入数组pfor(int k=0; k<i; k++)q[k]=ob1.ch[k]; //将不用替换的前部分存入数组q for(int m=i; m<i+StrLength(ob3); m++)q[m]=ob3.ch[m-i]; //替换子串int b=i+len;for(int n=i+StrLength(ob3); n<len2; n++){ //将不用替换的后部分存入数组qq[n]=p[b];b++; //数组q存储着新串}ob1.curLen=len2;for(int l=0; l<len2; l++)ob1.ch[l]=q[l]; //将新串赋值给ob1做循环替换}printf("新串：");for(int h=0; h<ob1.curLen; h++)printf("%c",ob1.ch[h]);}(5)串比较int Compare(HString s1, HString s2){ //若s1<s2则返回值<0; 若s1=s2则返回值=0; 若s1>s2则返回值>0int i;for(i=0; i<s1.curLen&&i<s2.curLen; ++i)if(s1.ch[i]!=s2.ch[i])return (s1.ch[i]-s2.ch[i]);return (s1.curLen-s2.curLen);}四．实验的结果及分析。

数据结构串的实验报告

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++进行编写，而且难度要比我预期的要低，效果反而更好了。

同时，串基于字符数组实现要容易得多，而且对于一维数组的具体操作，已经相对较为熟练，而且也提供了很多关于字符串的相关函数，所以为了提高编程水平，这次对于串的操作，都不依赖系统函数和字符串函数，相反，深入初始化，插入，删除，遍历等功能的本质，对字符串的底层进行编程实现。

电路串联设计实验报告

电路串联设计实验报告引言电路串联是一种基本的电路连接方式，通过将多个电路元件依次连接在一起，形成一个整体功能电路。

在本次实验中，我们将学习并设计一个电路串联实验，并进行实际操作和测试。

实验目的1. 了解电路串联的原理和应用；2. 掌握串联电路的设计和连接方法；3. 学习使用仪器测量电路参数。

实验仪器和材料1. 电压源；2. 电流表；3. 电阻器（多个）；4. 连线、示波器等其他实验器材。

实验步骤步骤一：准备工作1. 检查实验仪器和材料的完好性；2. 将电流表、电源和电阻器准备好。

步骤二：电路串联连接1. 将电压源的正极与电阻器1的一端相连，将电源的负极与电阻器2的一端相连；2. 将电阻器1的另一端与电阻器2的另一端相连，以此类推，将所有电阻器依次连接在一起；3. 确保所有连接牢固可靠，没有短路或断路现象。

步骤三：测量电路参数1. 将电流表连接在电路的某个位置，以测量电路中的电流；2. 通过调节电源的电压，测量不同电压下电路中的电流，并记录数据；3. 根据测量数据，计算电路的总电流和每个电阻器的电流，并记录数据。

步骤四：数据分析和结果验证1. 分析电流和电压的关系，是否符合欧姆定律的规律；2. 比较实际测量值与理论计算值的差异，分析可能的误差来源；3. 验证串联电路的性质，例如电阻值的相加等内容。

结果与讨论通过实验，我们成功设计了一个电路串联实验并完成了实际操作和测量。

通过测量数据和数据分析，我们得出了以下结论：1. 电流和电压满足欧姆定律的规律，即电流与电压成正比；2. 实际测量值与理论计算值有一定的误差，可能是由于仪器的精确度、连接电阻的不完全理想等原因造成；3. 串联电路的总电阻等于每个电阻器的电阻值之和，验证了串联电路电阻的相加规律。

实验总结通过本次实验，我们深入理解了电路串联的原理和应用，掌握了串联电路的设计和连接方法，并学会了使用仪器测量电路参数。

实验结果与理论相符，这次实验取得了较好的效果。

串的操作实验报告

数据结构实验报告报告名称串的操作专业网络工程班级学号姓名指导教师陈淑红李珍辉黄哲年月日一、实验目的：熟悉串类型的实现方法，了解简单文字处理的设计方法。

二、实验内容与基本要求：1.设计可以在主串s中第i个位置之前插入一个子串t的程序。

2.设计可以在主串s中从第i个位置开始共取m个字符，求子串的程序。

3.设计一个程序求子串t在主串s中的起始位置三、概要设计：1.数据结构：#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char data[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;2.抽象数据类型：ADT String {数据对象：D＝{ a i |a i∈CharacterSet,i=1,2,...,n, n≥0 }数据关系：R1＝{ < a i-1, a i > | a i-1, a i∈D, i=2,...,n }StrAssign (&T, chars)初始条件：chars 是字符串常量。

操作结果：把chars 赋为T 的值。

StrCopy (&T, S)初始条件：串S 存在。

操作结果：由串S 复制得串T。

DestroyString (&S)初始条件：串S 存在。

操作结果：串S 被销毁。

StrEmpty(S)初始条件：串S存在。

操作结果：若S 为空串，则返回TRUE，否则返回FALSE。

StrCompare (S, T)初始条件：串S 和T 存在。

操作结果：若S > T，则返回值> 0；若S = T，则返回值= 0；若S < T，则返回值< 0。

StrLength (S)初始条件：串S 存在。

操作结果：返回S 的元素个数，称为串的长度。

Concat (&T, S1, S2)初始条件：串S1 和S2 存在。

数据结构实验报告-串

实验四串【实验目的】1、掌握串的存储表示及基本操作；2、掌握串的两种模式匹配算法：BF和KMP。

3、了解串的应用。

【实验学时】2学时【实验预习】回答以下问题：1、串和子串的定义串的定义：串是由零个或多个任意字符组成的有限序列。

子串的定义：串中任意连续字符组成的子序列称为该串的子串。

2、串的模式匹配串的模式匹配即子串定位是一种重要的串运算。

设s和t是给定的两个串，从主串s的第start个字符开始查找等于子串t的过程称为模式匹配，如果在S中找到等于t的子串，则称匹配成功，函数返回t在s中首次出现的存储位置（或序号）；否则，匹配失败，返回0。

【实验内容和要求】1、按照要求完成程序exp4_1.c，实现串的相关操作。

调试并运行如下测试数据给出运行结果：•求“This is a boy”的串长；•比较”abc3”和“abcde“；表示空格•比较”english”和“student“；•比较”abc”和“abc“；•截取串”white”，起始2，长度2；•截取串”white”，起始1，长度7；•截取串”white”，起始6，长度2；•连接串”asddffgh”和”12344”；#include<stdio.h>#include<string.h>#define MAXSIZE 100#define ERROR 0#define OK 1/*串的定长顺序存储表示*/typedef struct{char data[MAXSIZE];int length;} SqString;int strInit(SqString *s);/*初始化串*/int strCreate(SqString *s); /*生成一个串*/int strLength(SqString *s); /*求串的长度*/int strCompare(SqString *s1,SqString *s2); /*两个串的比较*/int subString(SqString *sub,SqString *s,int pos,int len);/*求子串*/int strConcat(SqString *t,SqString *s1,SqString *s2);/*两个串的连接*//*初始化串*/int strInit(SqString *s){s->length=0;s->data[0]='\0';return OK;}/*strInit*//*生成一个串*/int strCreate(SqString *s){printf("input string :");gets(s->data);s->length=strlen(s->data);return OK;}/*strCreate*//*（1）---求串的长度*/int strLength(SqString *s){return s->length;}/*strLength*//*（2）---两个串的比较，S1>S2返回>0，s1<s2返回<0，s1==s2返回0*/int strCompare(SqString *s1,SqString *s2){int i;for(i=0;i<s1->length&&i<s2->length;i++){if(s1->data[i]>s2->data[i]){return 1;}if(s1->data[i]<s2->data[i]){return -1;}}return 0;}/*strCompare*//*（3）---求子串，sub为返回的子串，pos为子串的起始位置，len为子串的长度*/int subString(SqString *sub,SqString *s,int pos,int len) {int i;if(pos<1||pos>s->length||len<0||len>s->length-pos+1) {return ERROR;}sub->length=0;for(i=0;i<len;i++){sub->data[i]=s->data[i+pos-1];sub->length++;}sub->data[i]='\0';return OK;}/*subString*//*（4）---两个串连接，s2连接在s1后，连接后的结果串放在t中*/int strConcat(SqString *t,SqString *s1,SqString *s2){int i=0,j=0;while(i<s1->length){t->data[i]=s1->data[i];i++;}while(j<s2->length){t->data[i++]=s2->data[j++];}t->data[i]='\0';t->length=s1->length+s2->length;return OK;}/*strConcat*/int main(){int n,k,pos,len;SqString s,t,x;do{printf("\n ---String--- \n");printf(" 1. strLentgh\n");printf(" 2. strCompare\n");printf(" 3. subString\n");printf(" 4. strConcat\n");printf(" 0. EXIT\n");printf("\n ---String---\n");printf("\ninput choice:");scanf("%d",&n);getchar();switch(n){case 1:printf("\n***show strLength***\n");strCreate(&s);printf("strLength is %d\n",strLength(&s));break;case 2:printf("\n***show strCompare***\n");strCreate(&s);strCreate(&t);k=strCompare(&s,&t); /*（5）---调用串比较函数比较s，t*/if(k==0)printf("two string equal!\n");else if(k<0)printf("first string<second string!\n");elseprintf("first string>second string!\n");break;case 3:printf("\n***show subString***\n");strCreate(&s);printf("input substring pos,len:");scanf("%d,%d",&pos,&len);if(subString(&t,&s,pos,len))printf("subString is %s\n",t.data);elseprintf("pos or len ERROR!\n");break;case 4:printf("\n***show subConcat***\n");strCreate(&s);strCreate(&t);if(strConcat(&x,&s,&t)) /*（6）---调用串连接函数连接s&t*/printf("Concat string is %s",x.data);elseprintf("Concat ERROR!\n");break;case 0:exit(0);default:break;}}while(n);return 0;}2、按照要求完成程序exp4_2.c，实现BF&KMP串的模式匹配算法。

串联电路实验步骤

串联电路实验步骤
串联电路是电路的基本形式之一，通过串联电路的实验可以深入理解电路的工作原理。

下面将详细介绍串联电路实验的步骤，以帮助您更好地进行实验操作。

一、实验准备
在进行串联电路实验之前，需要准备以下材料和工具：
1. 电源：用于提供电能，例如电池或稳压电源。

2. 导线：用于连接电路元件，建议使用绝缘导线。

3. 电阻器：用于模拟电路中的电阻元件，可以选择不同阻值的电阻器进行实验。

4. 开关：用于控制电路的通断。

5. 仪表：用于测量电路中的电压、电流等参数，例如万用表。

6. 实验板：用于固定电路元件和导线，方便实验操作。

二、实验步骤
1. 搭建电路
在实验板上画出串联电路的原理图，根据原理图搭建实际电路。

确保导线连接牢固，元件放置合理。

2. 测量电压
使用万用表分别测量电路中各个节点之间的电压，记录测量结果。

注意在测量电压时要关闭电源。

3. 测量电流
将电流表串入电路中，测量电路的总电流和各个电阻器支路的电流，记录测量结果。

4. 分析数据
根据测量结果，分析串联电路中电压和电流的关系，验证欧姆定律。

注意比较理论值和实验值之间的差异，分析原因。

5. 改变电阻值
更换不同阻值的电阻器，重复实验步骤2、3、4，观察不同阻值对电路中电压和电流的影响。

6. 总结归纳
根据实验数据和结果，总结串联电路的特点和规律，例如电压和电流的关系、电阻的串并联计算等。

串的操作实验报告

一、实验目的1. 理解串的概念及其在程序设计中的应用。

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

3. 提高对数据结构操作的理解和编程能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 创建串2. 插入字符3. 删除字符4. 查找字符5. 合并串6. 判断串是否为空7. 获取串的长度8. 反转串四、实验步骤1. 创建串```cpp#include <iostream>#include <string>using namespace std;int main() {string str1 = "Hello";string str2 = "World";return 0;}```2. 插入字符```cppint main() {string str = "Hello";int position = 3;char ch = 'W';str.insert(position, 1, ch);cout << str << endl; // 输出：HWeHllo return 0;}```3. 删除字符```cppint main() {string str = "Hello";int position = 2;int length = 2;str.erase(position, length);cout << str << endl; // 输出：Hereturn 0;}```4. 查找字符```cppint main() {string str = "Hello";char ch = 'e';size_t position = str.find(ch);cout << position << endl; // 输出：1return 0;}```5. 合并串```cppint main() {string str1 = "Hello";string str2 = "World";string str3 = str1 + str2;cout << str3 << endl; // 输出：HelloWorld return 0;}```6. 判断串是否为空```cppint main() {string str1 = "Hello";string str2 = "";if (str1.empty()) {cout << "str1 is empty" << endl;} else {cout << "str1 is not empty" << endl; }if (str2.empty()) {cout << "str2 is empty" << endl;} else {cout << "str2 is not empty" << endl; }return 0;}```7. 获取串的长度```cppint main() {string str = "Hello";int length = str.length();cout << length << endl; // 输出：5return 0;}```8. 反转串```cppint main() {string str = "Hello";reverse(str.begin(), str.end());cout << str << endl; // 输出：olleHreturn 0;}```五、实验结果与分析通过以上实验，我们成功实现了串的基本操作。