数据结构-顺序串基本操作实验报告
数据结构串的基本操作及应用实验报告
实验日期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）、熟悉C语言的上机环境，进一步掌握C语言的结构特点；（2）、掌握串的定义及C语言实现；（3）、掌握串的模式匹配及C语言实现；（4）、掌握串的各种基本操作；实验步骤：（1）、建立链串类型（2）、实现匹配过程中需考虑的链表的特征。
实验内容：4.一个字符串中的任意一个子序列，若子序列中各字符值均相同，则成为字符平台。
写一算法，输入任意以字符串S，输出S中长度最大的所有字符平台的起始位置及所含字符。
注意，最大字符平台有可能不止一个。
实验数据记录：（源代码及执行过程）#include<stdio.h>#include<stdlib.h>#define Maxsize 20#define n 100typedef struct Node{int element[Maxsize];int front;int rear;}Queue;int EnterQueue(Queue *Q,int x){if((Q->rear+1)%Maxsize == Q->front){printf("队列已满!\n");return 0;}Q->element[Q->rear] = x;Q->rear = (Q->rear+1)%Maxsize;return 1;}int DeleQueue(Queue *Q,int *x){if(Q->front == Q->rear){printf("队列为空!\n");return 0;}*x = Q->element[Q->front];Q->front = (Q->front+1)%Maxsize;return 1;}int Donull(Queue *Q){while(Q->front != Q->rear){Q->element[Q->front] = 0;Q->front = (Q->front+1)%Maxsize;}Q->front = Q->rear = 0;if(Q->front == Q->rear){return 1;}else{return 0;}}int main(void){char str[n];int i=0,j=1,k=1,ch,p=1,flag=1;Queue *Q;Q = (Queue *)malloc(sizeof(Queue));Q->front = Q->rear = 0;printf("请输入字符串：");gets(str);while('\0' != *(str+i)){ while(*(str+i+1) == *(str+i)){if(flag){p = i;flag = 0;}i++;j++;}if(flag){p = i;}if(j >= k){if(j > k){Donull(Q);k = j;}if(EnterQueue(Q ,j) == 0)break;if(EnterQueue(Q,p+1) == 0)break;if(EnterQueue(Q,*(str+i)) == 0)break;}j=1;i++;flag = 1;} while(Q->front < Q->rear){DeleQueue(Q,&j);DeleQueue(Q,&k);DeleQueue(Q,&ch);printf("%-10d",k);for(i = 0; i < j; i++){printf("%c",ch);}printf("\n");}printf("\n");system("pause");}。
数据结构顺序串基本操作实验报告
数据结构顺序串基本操作实验报告实验目的：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实验总结：本次实验主要是对顺序串的基本操作进行了实现和验证。
串-数据结构实验报告
串-数据结构实验报告串数据结构实验报告一、实验目的本次实验的主要目的是深入理解和掌握串这种数据结构的基本概念、存储方式以及相关的操作算法。
通过实际编程实现串的基本操作，提高对数据结构的理解和编程能力，培养解决实际问题的思维和方法。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理（一）串的定义串是由零个或多个字符组成的有限序列。
在本次实验中，我们主要关注的是字符串。
（二）串的存储方式1、顺序存储定长顺序存储：使用固定长度的数组来存储字符串，长度不足时用特定字符填充。
堆分配存储：根据字符串的实际长度动态分配存储空间。
2、链式存储每个节点存储一个字符，并通过指针链接起来。
（三）串的基本操作1、串的创建和初始化2、串的赋值3、串的连接4、串的比较5、求子串6、串的插入和删除四、实验内容及步骤（一）顺序存储方式下串的实现1、定义一个结构体来表示顺序存储的字符串，包含字符数组和字符串的实际长度。
｀｀｀cppstruct SeqString ｛char str;int length;｝；｀｀｀2、实现串的创建和初始化函数｀｀｀cppSeqString createSeqString(const char initStr) ｛int len ＝ strlen(initStr)；SeqString s;sstr ＝ new charlen ＋ 1;strcpy(sstr, initStr)；slength ＝ len;return s;｝｀｀｀3、串的赋值函数｀｀｀cppvoid assignSeqString(SeqString& s, const char newStr) ｛delete sstr;int len ＝ strlen(newStr)；sstr ＝ new charlen ＋ 1;strcpy(sstr, newStr)；slength ＝ len;｝｀｀｀4、串的连接函数｀｀｀cppSeqString concatSeqString(const SeqString& s1, const SeqString& s2) ｛SeqString result;resultlength ＝ s1length ＋ s2length;resultstr ＝ new charresultlength ＋ 1;strcpy(resultstr, s1str)；strcat(resultstr, s2str)；return result;｝｀｀｀5、串的比较函数｀｀｀cppint compareSeqString(const SeqString& s1, const SeqString& s2) ｛return strcmp(s1str, s2str)；｝｀｀｀6、求子串函数｀｀｀cppSeqString subSeqString(const SeqString& s, int start, int len) ｛SeqString sub;sublength ＝ len;substr ＝ new charlen ＋ 1;strncpy(substr, sstr ＋ start, len)；substrlen ＝＇＼0'；return sub;｝｀｀｀7、串的插入函数｀｀｀cppvoid insertSeqString(SeqString& s, int pos, const SeqString& insertStr) ｛int newLength ＝ slength ＋ insertStrlength;char newStr ＝ new charnewLength ＋ 1;strncpy(newStr, sstr, pos)；strcpy(newStr ＋ pos, insertStrstr)；strcpy(newStr ＋ pos ＋ insertStrlength, sstr ＋ pos)；delete sstr;sstr ＝ newStr;slength ＝ newLength;｝｀｀｀8、串的删除函数｀｀｀cppvoid deleteSeqString(SeqString& s, int start, int len) ｛int newLength ＝ slength len;char newStr ＝ new charnewLength ＋ 1;strncpy(newStr, sstr, start)；strcpy(newStr ＋ start, sstr ＋ start ＋ len)；delete sstr;sstr ＝ newStr;slength ＝ newLength;｝｀｀｀（二）链式存储方式下串的实现1、定义一个节点结构体｀｀｀cppstruct LinkNode ｛char data;LinkNode next;LinkNode(char c) ： data(c)， next(NULL) ｛｝｝；｀｀｀2、定义一个链式存储的字符串类｀｀｀cppclass LinkString ｛private:LinkNode head;int length;public:LinkString(const char initStr)；～LinkString(）；void assign(const char newStr)；LinkString concat(const LinkString& other)；int compare(const LinkString& other)；LinkString subString(int start, int len)；void insert(int pos, const LinkString& insertStr)；void deleteSub(int start, int len)；｝；｀｀｀3、实现各个函数｀｀｀cppLinkString:：LinkString(const char initStr) ｛length ＝ strlen(initStr)；head ＝ NULL;LinkNode p ＝ NULL;for （int i ＝ 0; i ＜ length; i+＋）｛LinkNode newNode ＝ new LinkNode(initStri)；if （head ＝＝ NULL) ｛head ＝ newNode;p ＝ head;｝ else ｛p>next ＝ newNode;p ＝ p>next;｝｝｝LinkString:：～LinkString(）｛LinkNode p ＝ head;while （p) ｛LinkNode temp ＝ p;p ＝ p>next;delete temp;｝｝void LinkString:：assign(const char newStr) ｛／／先释放原有的链表LinkNode p ＝ head;while （p) ｛LinkNode temp ＝ p;p ＝ p>next;delete temp;｝length ＝ strlen(newStr)；head ＝ NULL;p ＝ NULL;for （int i ＝ 0; i ＜ length; i+＋）｛LinkNode newNode ＝ new LinkNode(newStri)；if （head ＝＝ NULL) ｛head ＝ newNode;p ＝ head;｝ else ｛p>next ＝ newNode;p ＝ p>next;｝｝｝LinkString LinkString:：concat(const LinkString& other) ｛LinkString result;LinkNode p1 ＝ head;LinkNode p2 ＝ otherhead;LinkNode p ＝ NULL;while （p1) ｛LinkNode newNode ＝ new LinkNode(p1-＞data)；if （resulthead ＝＝ NULL) ｛resulthead ＝ newNode;p ＝ resulthead;｝ else ｛p>next ＝ newNode;p ＝ p>next;｝p1 ＝ p1-＞next;｝while （p2) ｛LinkNode newNode ＝ new LinkNode(p2-＞data)；if （resulthead ＝＝ NULL) ｛resulthead ＝ newNode;p ＝ resulthead;｝ else ｛p>next ＝ newNode;p ＝ p>next;｝p2 ＝ p2-＞next;｝resultlength ＝ length ＋ otherlength;return result;｝int LinkString:：compare(const LinkString& other) ｛LinkNode p1 ＝ head;LinkNode p2 ＝ otherhead;while （p1 ＆＆ p2 ＆＆ p1-＞data ＝＝ p2-＞data) ｛p1 ＝ p1-＞next;p2 ＝ p2-＞next;｝if （p1 ＝＝ NULL ＆＆ p2 ＝＝ NULL) ｛return 0;｝ else if （p1 ＝＝ NULL) ｛return －1;｝ else if （p2 ＝＝ NULL) ｛return 1;｝ else ｛return p1-＞data p2-＞data;｝｝LinkString LinkString:：subString(int start, int len) ｛LinkString sub;LinkNode p ＝ head;for （int i ＝ 0; i ＜ start; i+＋）｛p ＝ p>next;｝for （int i ＝ 0; i ＜ len; i+＋）｛LinkNode newNode ＝ new LinkNode(p>data)；if （subhead ＝＝ NULL) ｛subhead ＝ newNode;｝ else ｛LinkNode temp ＝ subhead;while （temp>next) ｛temp ＝ temp>next;｝temp>next ＝ newNode;｝p ＝ p>next;｝sublength ＝ len;return sub;｝void LinkString:：insert(int pos, const LinkString& insertStr) ｛LinkNode p ＝ head;for （int i ＝ 0; i ＜ pos 1; i+＋）｛p ＝ p>next;｝LinkNode insertHead ＝ insertStrhead;while （insertHead) ｛LinkNode newNode ＝ new LinkNode(insertHead>data)；newNode>next ＝ p>next;p>next ＝ newNode;p ＝ p>next;insertHead ＝ insertHead>next;｝length ＋＝ insertStrlength;｝void LinkString:：deleteSub(int start, int len) ｛LinkNode p ＝ head;for （int i ＝ 0; i ＜ start 1; i+＋）｛p ＝ p>next;｝LinkNode temp ＝ p>next;for （int i ＝ 0; i ＜ len; i+＋）｛LinkNode delNode ＝ temp;temp ＝ temp>next;delete delNode;｝p>next ＝ temp;length ＝ len;｝｀｀｀（三）测试用例1、顺序存储方式的测试｀｀｀cppint main(）｛SeqString s1 ＝ createSeqString(＂Hello"）；SeqString s2 ＝ createSeqString(＂World"）；SeqString s3 ＝ concatSeqString(s1, s2)；std:：cout ＜＜＂连接后的字符串: ＂＜＜ s3str ＜＜ std:：endl; int cmpResult ＝ compareSeqString(s1, s2)；if （cmpResult ＜ 0) ｛std:：cout ＜＜＂s1 小于 s2" ＜＜ std:：endl;｝ else if （cmpResult ＝＝ 0) ｛std:：cout ＜＜＂s1 等于 s2" ＜＜ std:：endl;｝ else ｛std:：cout ＜＜＂s1 大于 s2" ＜＜ std:：endl;｝SeqString sub ＝ subSeqString(s1, 1, 3)；std:：cout ＜＜＂子串: ＂＜＜ substr ＜＜ std:：endl; insertSeqString(s1, 2, s2)；std:：cout ＜＜＂插入后的字符串: ＂＜＜ s1str ＜＜ std:：endl; deleteSeqString(s1, 3, 2)；std:：cout ＜＜＂删除后的字符串: ＂＜＜ s1str ＜＜ std:：endl; return 0;｝｀｀｀2、链式存储方式的测试｀｀｀cppint main(）｛LinkString ls1(＂Hello"）；LinkString ls2(＂World"）；LinkString ls3 ＝ ls1concat(ls2)；std:：cout ＜＜＂连接后的字符串: ＂；LinkNode p ＝ ls3head;while （p) ｛std:：cout ＜＜ p>data;p ＝ p>next;｝std:：cout ＜＜ std:：endl;int cmpResult ＝ ls1compare(ls2)；if （cmpResult ＜ 0) ｛std:：cout ＜＜＂ls1 小于 ls2" ＜＜ std:：endl;｝ else if （cmpResult ＝＝ 0) ｛std:：cout ＜＜＂ls1 等于 ls2" ＜＜ std:：endl;｝ else ｛std:：cout ＜＜＂ls1 大于 ls2" ＜＜ std:：endl;｝LinkString sub ＝ ls1subString(1, 3)；std:：cout ＜＜＂子串: ＂；p ＝ subhead;while （p) ｛std:：cout ＜＜ p>data;p ＝ p>next;｝std:：cout ＜＜ std:：endl;ls1insert(2, ls2)；std:：cout ＜＜＂插入后的字符串: ＂；p ＝ ls1head;while （p) ｛std:：cout ＜＜ p>data;p ＝ p>next;｝std:：cout ＜＜ std:：endl;ls1deleteSub(3, 2)；std:：cout ＜＜＂删除后的字符串: ＂；p ＝ ls1head;while （p) ｛std:：cout ＜＜ p>data;p ＝ p>next;｝std:：cout ＜＜ std:：endl;return 0;｝｀｀｀五、实验结果及分析（一）顺序存储方式1、连接操作成功实现，输出了正确连接后的字符串。
《数据结构》实验报告——排序
《数据结构》实验报告排序实验题目：输入十个数，从插入排序，快速排序，选择排序三类算法中各选一种编程实现。
实验所使用的数据结构内容及编程思路：1.插入排序：直接插入排序的基本操作是，将一个记录到已排好序的有序表中，从而得到一个新的，记录增一得有序表。
一般情况下，第i趟直接插入排序的操作为：在含有i-1个记录的有序子序列r［1..i-1］中插入一个记录r［i］后，变成含有i个记录的有序子序列r［1..i］；并且，和顺序查找类似，为了在查找插入位置的过程中避免数组下标出界，在r［0］处设置哨兵。
在自i-1起往前搜索的过程中，可以同时后移记录。
整个排序过程为进行n-1趟插入，即：先将序列中的第一个记录看成是一个有序的子序列，然后从第2个记录起逐个进行插入，直至整个序列变成按关键字非递减有序序列为止。
2.快速排序：基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
假设待排序的序列为{L.r[s]，L.r[s+1],…L.r[t]},首先任意选取一个记录(通常可选第一个记录L.r[s])作为枢轴（或支点）（pivot），然后按下述原则重新排列其余记录：将所有关键字较它小的记录都安置在它的位置之前，将所有关键字较大的记录都安置在它的位置之后。
由此可以该“枢轴”记录最后所罗的位置i作为界线，将序列{L.r[s]，…，L.r[t]}分割成两个子序列{L.r[i+1],L.[i+2],…,L.r[t]}。
这个过程称为一趟快速排序，或一次划分。
一趟快速排序的具体做法是：附设两个指针low和high，他们的初值分别为low和high，设枢轴记录的关键字为pivotkey，则首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换，然后从low所指位置起向后搜索，找到第一个关键字大于pivotkey的记录和枢轴记录互相交换，重复这两不直至low=high为止。
顺序栈基本操作实验报告
数据结构实验三课程数据结构实验名称顺序栈基本操作第页专业班级学号姓名实验日期：年月日评分一、实验目的1．熟悉并能实现栈的定义和基本操作。
2．了解和掌握栈的应用。
二、实验要求1．进行栈的基本操作时要注意栈"后进先出"的特性。
2．编写完整程序完成下面的实验内容并上机运行。
3．整理并上交实验报告。
三、实验内容1．编写程序任意输入栈长度和栈中的元素值，构造一个顺序栈，对其进行清空、销毁、入栈、出栈以及取栈顶元素操作。
2．编写程序实现表达式求值，即验证某算术表达式的正确性，若正确，则计算该算术表达式的值。
主要功能描述如下：（1）从键盘上输入表达式。
（2）分析该表达式是否合法：•a) 是数字，则判断该数字的合法性。
若合法，则压入数据到堆栈中。
•b) 是规定的运算符，则根据规则进行处理。
在处理过程中，将计算该表达式的值。
•c) 若是其它字符，则返回错误信息。
（3）若上述处理过程中没有发现错误，则认为该表达式合法，并打印处理结果。
程序中应主要包含下面几个功能函数：•l void initstack()：初始化堆栈•l int Make_str()：语法检查并计算•l int push_operate(int operate)：将操作码压入堆栈•l int push_num(double num)：将操作数压入堆栈•l int procede(int operate)：处理操作码•l int change_opnd(int operate)：将字符型操作码转换成优先级•l int push_opnd(int operate)：将操作码压入堆栈•l int pop_opnd()：将操作码弹出堆栈•l int caculate(int cur_opnd)：简单计算+，-，*，/•l double pop_num()：弹出操作数四、实验步骤（描述实验步骤及中间的结果或现象。
在实验中做了什么事情，怎么做的，发生的现象和中间结果）第一题：#include <iostream>using namespace std;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量#define OVERFLOW -1#define OK 1#define NO -1#define NULL 0typedef int Status;typedef char SElemType;typedef struct{SElemType *base; //在栈构造之前和销毁之后，base的值为NULLSElemType *top; //栈顶指针int stacksize; //当前已分配的存储空间，以元素为单位} SqStack;Status Initstack(SqStack &S)//构造一个空栈S{S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base)exit(OVERFLOW);S.top=S.base;S.stacksize= STACK_INIT_SIZE;return OK;}//InitStackStatus StackEmpty(SqStack &S){if(S.base==S.top)return OK;elsereturn NO;}Status ClearStack (SqStack &S)//把S置为空{if(S.base=S.top);return OK;}Status DsetroyStack (SqStack &S)//销毁栈S{S.base=NULL;return OK;}Status Push(SqStack &S,SElemType e)//插入元素e为新的栈顶元素{if (S.top-S.base>=S.stacksize){S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S.base) //存储分配失败exit(OVERFLOW);S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}//PushStatus Pop(SqStack &S,SElemType &c)//若栈不空，则删除S的栈顶元素，用c返回其值，并返回OK；否则返回ERROR {if(S.top==S.base)return NO;c=*--S.top;return OK;}//PopStatus GetTop(SqStack &S,SElemType &e){if (S.top==S.base)return NO;e=*(S.top-1);return OK;}//GetTopint main(){SqStack S;Initstack(S);cout<<"输入要压到栈中的元素!"<<endl;char c;while((c=getchar())!='\n'){Push(S,c);}GetTop(S,c);cout<<"栈顶元素为："<<c<<endl;//ClearStack (S);//DsetroyStack(S);for(int i=0;S.top!=S.base;i++){Pop(S,c);cout<<"栈中第"<<i+1<<"元素的值:";cout<<c<<endl;}return 0;}第二题：#include<iostream>using namespace std;#define STACK_SIZE 100#define STACKINCREMENT 10#define OVERFLOW -1#define OK 1#define NO 0typedef int Status;typedef char SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int main(){char GetTop(SqStack &s);Status Initstack(SqStack &s);Status push_operate(SqStack &s,SElemType e);Status push_num(SqStack &s,int e);Status Stackempty(SqStack &s);Status pop_num(SqStack &s,int &c);Status pushoperate(SElemType operate);Status pushnum(SElemType num);Status caculate(SElemType a,SElemType operate,SElemType b);Status pop_operate(SqStack &s,SElemType &c);Status change(SElemType e);char Precede(SElemType a,SElemType b);char Operatecxz();int m;m=Operatecxz();cout<<m<<endl;return 0;}Status change(SElemType e){int m;m=e-48;return m;}Status Initstack(SqStack &s){s.base=(SElemType *)malloc(STACK_SIZE*sizeof(SElemType));if(!s.base)exit(OVERFLOW);s.top=s.base;s.stacksize=STACK_SIZE;return OK;}Status Stackempty(SqStack &s){if(s.base==s.top)return OK;elsereturn NO;}Status push_num(SqStack &s,int e){if(s.top-s.base>=s.stacksize){s.base=(SElemType*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));if(!s.base)exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=STACKINCREMENT;}*s.top++=e;return OK;}Status push_operate(SqStack &s,SElemType e){if(s.top-s.base>=s.stacksize){s.base=(SElemType*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));if(!s.base)exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=STACKINCREMENT;}*s.top++=e;return OK;}Status pop_operate(SqStack &s,SElemType &c){if(s.top==s.base)return NO;c=*--s.top;return OK;}Status pop_num(SqStack &s,int &c){if(s.top==s.base)return NO;c=*--s.top;return OK;}char GetTop(SqStack &s){char c;if(s.top==s.base)return NO;c=*(s.top-1);return c;}Status caculate(int a,SElemType operate,int b){int s;if(operate=='+')s=a+b;if(operate=='-')s=a-b;if(operate=='*')s=a*b;if(operate=='/')s=a/b;return s;}Status In(SElemType c){if(c=='+'||c=='-'||c=='*'||c=='/'||c=='#'||c=='('||c==')') return OK;if(c>='0'&&c<='9')return NO;return -1;}char Precede(SElemType a,SElemType b){if(a=='+'||a=='-'){if(b=='+'||b=='-'||b==')'||b=='#')return '>';if(b=='*'||b=='/'||b=='(')return '<';}if(a=='*'||a=='/'){if(b=='+'||b=='-'||b==')'||b=='*'||b=='/'||b=='#')return '>';if(b=='(')return '<';}if(a=='('){if(b==')')return '=';if(b=='+'||b=='-'||b=='*'||b=='/')return '<';if(b=='#')return ' ';}if(a==')'){if(b==')')return ' ';if(b=='+'||b=='-'||b=='*'||b=='/'||b=='('||b=='#')return '>';}if(a=='#'){if(b=='#')return '=';if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(')return '<';if(b==')')return ' ';}return ' ';}char Operatecxz(){SqStack Operate,Num;char c,e,x;int num,a,b,flat=1,sz=0;Initstack(Operate);push_operate(Operate,'#');Initstack(Num);c=getchar();while(c!='#'||GetTop(Operate)!='#'){if(In(c)==-1){cout<<"input error!"<<endl;flat=0;break;}if(In(c)!=1){if(sz==0){num=change(c);sz=1;c=getchar();continue;}if(sz==1)num=num*10+change(c);c=getchar();continue;}else{if(sz==1)push_num(Num,num);sz=0;x=GetTop(Operate);switch(Precede(GetTop(Operate),c)){case '<':{push_operate(Operate,c);c=getchar();break;}case '=':{pop_operate(Operate,e);c=getchar();break;}case '>':{pop_num(Num,a);pop_operate(Operate,e);pop_num(Num,b);push_num(Num,caculate(b,e,a));break;}}}}pop_operate(Operate,e);if(e!='#')flat=0;if(flat==1){pop_num(Num,a);return a;}if(flat==0)return 0;}五．实验结果与讨论（描述最终得到的结果，并进行分析说明，可能的误差原因）第一题：1 把主函数中的ClearStack (S);DsetroyStack(S)注释掉的结果：2 不把ClearStack (S)注释掉，把栈清空：3 不把DsetroyStack(S)注释掉，即销毁栈：出现一堆乱码，说明销毁成功。
数据结构-顺序串基本操作实验报告
数据结构\顺序串基本操作实验报告实验报告数据结构\顺序串基本操作一、实验目的本实验旨在通过实践，掌握顺序串的基本操作，包括顺序串的初始化、销毁、插入、删除和查找等。
二、实验内容1\初始化顺序串2\销毁顺序串3\插入元素到顺序串4\删除顺序串中的指定元素5\查找顺序串中的指定元素三、实验步骤1\初始化顺序串顺序串的初始化就是创建一个空顺序串，可以通过创建一个定长数组来实现。
具体步骤如下：（1）定义一个定长数组，例如a[MAX_SIZE]，用于存储顺序串的元素。
（2）定义一个变量len，用于记录顺序串的当前长度，初值为0。
2\销毁顺序串销毁顺序串就是释放顺序串占用的内存空间，具体步骤如下：（1）释放数组a所占用的内存空间。
（2）将len重置为0。
3\插入元素到顺序串插入元素到顺序串就是在指定位置插入一个元素。
具体步骤如下：（1）判断插入位置的合法性，如果位置小于0或大于当前顺序串的长度，即为非法操作。
（2）将len加1，表示顺序串的长度增加了一个。
（3）将插入位置及其之后的元素依次后移一位。
（4）将需要插入的元素存放到插入位置处。
4\删除顺序串中的指定元素删除顺序串中的指定元素就是将顺序串中某个位置的元素删除。
具体步骤如下：（1）判断被删除位置的合法性，如果位置小于0或大于等于当前顺序串的长度，即为非法操作。
（2）将被删除位置之后的元素依次前移一位。
（3）将len减1，表示顺序串的长度减少了一个。
5\查找顺序串中的指定元素查找顺序串中的指定元素就是找出顺序串中第一个与给定元素相等的元素的位置。
具体步骤如下：（1）从顺序串的第一个元素开始逐个与给定元素比较，直到找到相等的元素或搜索到顺序串的末尾。
（2）返回相等元素的位置。
四、实验结果与分析根据实验步骤，我们可以完成顺序串的初始化、销毁、插入、删除和查找等基本操作。
通过这些操作，我们可以对顺序串进行各种元素的插入、删除和查找操作，方便实现顺序串的各种功能。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作，深入理解线性表的逻辑结构和存储结构，掌握顺序表的插入、删除、查找等操作的实现方法，提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为 C 语言，编程环境为 Visual Studio 2019。
三、实验原理顺序表是一种线性表的存储结构，它使用一组连续的存储单元依次存储线性表中的元素。
在顺序表中，元素的逻辑顺序与物理顺序是一致的。
顺序表的基本操作包括初始化、插入、删除、查找、遍历等。
在实现这些操作时，需要考虑顺序表的存储空间是否已满、插入和删除元素时元素的移动等问题。
四、实验内容（一）顺序表的定义｀｀｀cdefine MAXSIZE 100 ／／定义顺序表的最大长度typedef struct ｛int dataMAXSIZE; ／／存储顺序表的元素int length; ／／顺序表的当前长度｝ SeqList;｀｀｀（二）顺序表的初始化｀｀｀cvoid InitList(SeqList L) ｛L>length ＝ 0;｝｀｀｀（三）顺序表的插入操作｀｀｀cint InsertList(SeqList L, int i, int e) ｛if （L>length ＝＝ MAXSIZE) ｛／／顺序表已满return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length ＋ 1) ｛／／插入位置不合法return 0;｝for （int j ＝ L>length; j ＞＝ i; j) ｛／／移动元素L>dataj ＝ L>dataj 1;｝L>datai 1 ＝ e; ／／插入元素L>length+＋；return 1;｝｀｀｀（四）顺序表的删除操作｀｀｀cint DeleteList(SeqList L, int i, int e) ｛if （L>length ＝＝ 0) ｛／／顺序表为空return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length) ｛／／删除位置不合法｝e ＝ L>datai 1; ／／取出被删除的元素for （int j ＝ i; j ＜ L>length; j+＋）｛／／移动元素L>dataj 1 ＝ L>dataj;｝L>length;return 1;｝｀｀｀（五）顺序表的查找操作｀｀｀cint SearchList(SeqList L, int e) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ e) ｛return i ＋ 1;｝｝｝｀｀｀（六）顺序表的遍历操作｀｀｀cvoid TraverseList(SeqList L) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；｝｀｀｀五、实验步骤1、打开 Visual Studio 2019，创建一个新的 C 语言项目。
数据结构实验报告顺序栈
（封面）学生实验报告学院：国际经贸学院课程名称：数据结构专业班级：09电子商务姓名：学号：学生实验报告（经管类专业用）一、实验目的及要求：1、目的通过实验，实现顺序栈的各种基本运算。
2、内容及要求编写一个程序，实现顺序栈的各种基本运算，并在此基础上设计一个主程序完成下列功能：（1）初始化栈S。
（2）判断栈S是否非空。
（3）依次进栈元素a，b，c，d，e。
（4）判断栈S是否非空。
（5）输出栈的长度。
（6）输出从栈顶到栈底的元素。
（7）输出出栈序列；（8）判断链栈S是否为空；（9）释放链栈二、仪器用具：三、实验方法与步骤:一、查阅顺序栈等相关资料，熟悉顺序栈基本概念和流程二、“开展”顺序栈实验流程三、整理实验数据和文档，总结实验的过程，编写实验报告四、实验结果与数据处理：1、顺序栈的代码：#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top; //栈顶指针} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e) {if (s->top==MaxSize-1)return 0;s->top++;s->data[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e) {if (s->top==-1)return 0;e=s->data[s->top];s->top--;return 1;}int GetTop(SqStack *s,ElemType &e) {if (s->top==-1)return 0;e=s->data[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->data[i]);printf("\n");void main() {// 主函数SqStack S=(SqStack *)malloc(sizeof(SqStack)); printf("(1)初始化顺序栈\n");InitStack(S);printf("(2)判断顺序栈是否为空:\n"); StackEmpty(S);printf("(3)依次进栈元素a,b,c,d,e:\n");Push(S,'a');Push(S,'b');Push(S,'c');Push(S,'d');Push(S,'e');printf("(4)判断顺序栈是否为空:\n"); StackEmpty(S);printf("(5)输出栈长度:%d\n",StackLength(S)); printf("(6)输出从栈顶到栈底的元素:\n"); StackTraverse(S);printf("(7)读出栈顶元素:%d\n",GetTop(S,e));printf("(8)删除栈顶元素:%d\n",Pop(S,e));printf("(9)输出从栈顶到栈底的元素:\n");StackTraverse(S);printf("(10)判断顺序栈是否为空\n");StackEmpty(S);printf("(11)释放栈。
数据结构综合实验报告
一、实验目的和要求1理解串的一般线性表之间的差异。
2重点掌握在顺序串上和链串上实现串的基本运算算法。
3掌握串的简单匹配算法和KMP算法。
4灵活运用串这种数据结构解决一些综合应用问题。
二、实验环境、内容和方法实验内容：1实现顺序串的各种基本运算。
2实现链串的各种基本运算。
3实现顺序串的各种模式匹配运算。
4求一个串中出现的第一个最长重复串。
实验方法：通过上机操作完成各内容。
实验环境：实验用PC机一台，使用操作系统为Windows XP Professional，安装OFFICE 2003、VC++等软件。
三、实验过程描述实验题4.1实现顺序串各种基本运算的算法编写一个程序algo4-1.cpp，实现顺序串的各种基本运算，并在此基础上设计一个程序exp4-1.cpp 完成如下功能：1建立串谁“abcdefghefghefghijklmn”和串s1=”xyz”;2输出串s;3输出串s的长度；4在串s的第9个字符位置插入串s1而产生串s2;5输出串s2;6删除串s第2个字符开始的5个字符替换成串s1而产生串s2；7输出串s2;8将串s第2个字符开始的5个字符替换成串s1而产生串s2;s2;输出串9．10提取串s的第2个字符开始的10个字符而产生串s3;11输出串s3；12将串s1和串s2连接起来而产生串s4;13输出串s4.解：本工程Proj4_1组成结构如图4.1所示。
algo4-1.cpp文件，其中包含如下函数：StrAssign(SqString &str,char cstr[]):由串常量cstr创建串str. StrCopy(SqString &s,SqString t):将串t复制到串s.StrEqual(SqString s,SqString t):判断两个串s和t是否相同。
StrLength(SqString s):求串s的长度。
Concat(SqString s,SqString t):将串t连接到串s之后产生新串。
串-数据结构实验报告[修改版]
![串-数据结构实验报告[修改版]](https://img.taocdn.com/s3/m/c2761ee859eef8c75ebfb30c.png)
第一篇：串-数据结构实验报告【源程序】：#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三.实验结论及分析串的存储结构包含有顺序存储结构和链式存储结构。
在串的顺序存储结构中，表示串的长度通常有两种方法：一种方法是设置一个串的长度参数，其优点在于便于在算法中用长度参数控制循环过程；另一种方法是在串值得末尾添加结束标记，此种方法的优点在于便于系统自动实现。
数据结构_串的基本操作_课程设计_实验报告
顾名思义，串及其基本操作，就是要在理解串的基本概念和特征的基础 上，了解串的内部表示和处理方法。这样才能有效地实现串的基本操作。串，也 还是字符串，是一种特殊的线性表。特殊之处在于表中的每一个元素都是字符， 以及由此而要求的一些特殊操作。在串及其基本操作中，要求的操作有联接、求 串长、求子串、比较串的大小、串的插入、串的删除、子串的定位和置换。因为 所要进行的操作比较零散也比较多，所以就要用到多个函数把这个整体的课程设 计划分成多个模块来进行。每个函数对应一个功能。在主函数中，用一个菜单， 就可以将原来的已分模块的函数系统地进行检验及操作。在程序设计的过程中， 根据课程设计的目的和基本要求，注意一些容易出错的地方及问题。
printf("请输入两串字符串:");
scanf("%s%s",str1,str2);
if(strcmp(str1,str2)>0) printf("1");
2
循环下，输入一个数字。每个数字代表不同的功能。然后用一个 switch 语句，
不同的 case 对应不同的函数，如：case（0）就可以代表求字符串的串长。
数据结构实验报告-串
实验四串【实验目的】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串的模式匹配算法。
串的基本操作演示实验报告
串的基本操作演示实验报告学号：姓名：班级：一．实验环境问题描述：如果语言没有把串作为一个预先定义好的基本类型对待,又需要用该语言写一个涉及串操作的软件系统时，用户必须自己实现串类型。
试实现串类型，并写一个串的基本操作的演示系统。
基本要求: 在教科书4.2。
2节用堆分配存储表示实现HString串的最小操作子集的基础上，实现串抽象数据类型的其余基本操作（不使用C语言本身提供的串函数）.参数合法性检查必须严格。
说明：（在格式中,Φ表示0个、1个或多个空格所组成的串。
〈串标识〉表示一个内部名或一个串文字。
前者是一个串的唯一标识，是一种内部形式的（而不是字符形式的）标识符。
后者是两端由单引号括起来的仅可打印字符组成的序列.串内每两个连续的单引号表示一个单引号符。
）利用上述基本操作函数构造以下系统：它是一个命令解释程序，循环往复地处理用户键入的每一条命令,直至终止程序的命令为止。
命令定义如下：（1) 赋值.格式：AΦ〈串标识>Φ<回车〉用〈串标识>所表示的值建立新串,并显示新串的内部名和串值。
如：A′Hi!′（2）判相等。
格式：EΦ〈串标识1>Φ〈串标识2〉Φ〈回车〉若两串相等,则显示“EQUAL"，否则显示“UNEQUAL”。
（3）联接。
格式：CΦ<串标识1〉Φ〈串标识2>Φ〈回车〉将两串联接产生结果串，它的内部名和串值都显示出来.（5) 求子串格式：SΦ〈串标识〉Φ+〈数1〉Φ+〈数2〉Φ<回车>如果参数合法，则显示子串的内部名和串值。
<数〉不带正负号.（6）子串定位. 格式：IΦ〈串标识1〉Φ〈串标识2〉Φ〈回车〉显示第二个串在第一个串中首次出现时的位置。
（7）串替换格式：RΦ〈串标识1〉Φ〈串标识2〉Φ〈串标识2>Φ〈回车〉将第一个串中出现所有出现的第二个串用第三个串替换，显示结果串的内部名和串值，原串不变。
（0）退出格式：QΦ<回车> 结束程序的运行.二、实验内容编写一个程序，实现顺序串的各种基本运算,并在此基础上设计一个主程序.具体如下：编写栈的基本操作函数顺序串类型定义如下所示：typedef struct node｛char data;struct node ＊next;｝linkstring；（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。
数据结构排序实验报告
引言概述：数据结构排序实验是计算机科学与技术专业中一项重要的实践课程。
通过实验，可以深入理解和掌握不同排序算法的原理、特点和性能表现。
本文将针对数据结构排序实验进行详细的阐述和总结，包括实验目的、实验内容、实验结果分析和总结。
一、实验目的1. 加深对数据结构排序算法的理解：通过实验，掌握不同排序算法的工作原理和实现方式。
2. 分析和比较不同排序算法的性能：对比不同排序算法在不同数据规模下的时间复杂度和空间复杂度，理解它们的优劣势。
3. 提高编程和算法设计能力：通过实验的编写，提升对排序算法的实现能力和代码质量。
二、实验内容1. 选择排序算法：选择排序是一种简单直观的排序算法，将序列分为有序和无序两部分，每次从无序部分选择最小（最大）元素，放到有序部分的末尾（开头）。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析2. 插入排序算法：插入排序逐步构建有序序列，对于未排序的元素，在已排序序列中从后向前扫描，找到对应位置插入。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析3. 快速排序算法：快速排序利用分治的思想，将序列分为左右两部分，选取基准元素，将小于基准的放在左边，大于基准的放在右边，递归地对左右部分进行排序。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析4. 归并排序算法：归并排序是一种稳定的排序算法，通过将序列分为若干子序列，分别进行排序，然后再将排好序的子序列合并成整体有序序列。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析5. 堆排序算法：堆是一种特殊的树状数据结构，堆排序利用堆的性质进行排序，通过构建大顶堆或小顶堆，并逐个将堆顶元素移出形成有序序列。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析三、实验结果分析1. 比较不同排序算法的执行时间：根据实验数据和分析，对比不同排序算法在不同数据规模下的执行时间，并针对其时间复杂度进行验证和分析。
顺序串的实验报告
一、实验目的1. 理解顺序串的概念及其特点；2. 掌握顺序串的创建、操作和遍历方法；3. 熟悉顺序串在编程中的应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容1. 创建顺序串2. 操作顺序串3. 遍历顺序串4. 应用顺序串四、实验步骤1. 创建顺序串```javaimport java.util.Scanner;public class SequenceString {public static void main(String[] args) {Scanner scanner = new Scanner(System.in); System.out.println("请输入字符串：");String input = scanner.nextLine();String sequenceString = new String(input);System.out.println("创建顺序串成功！");}}```2. 操作顺序串```javaimport java.util.Scanner;public class SequenceString {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入字符串：");String input = scanner.nextLine();String sequenceString = new String(input);// 判断字符串是否为空if (sequenceString.isEmpty()) {System.out.println("字符串为空！");} else {// 判断字符串是否为空串if (sequenceString.equals("")) {System.out.println("字符串为空串！"); } else {// 判断字符串是否为空格if (sequenceString.trim().isEmpty()) {System.out.println("字符串为空格！");} else {// 获取字符串长度int length = sequenceString.length();System.out.println("字符串长度为：" + length); }}}}}```3. 遍历顺序串```javaimport java.util.Scanner;public class SequenceString {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入字符串：");String input = scanner.nextLine();String sequenceString = new String(input);// 遍历字符串for (int i = 0; i < sequenceString.length(); i++) {char c = sequenceString.charAt(i);System.out.println("字符 " + (i + 1) + "：" + c);}}}```4. 应用顺序串```javaimport java.util.Scanner;public class SequenceString {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入字符串：");String input = scanner.nextLine();String sequenceString = new String(input);// 查找字符串中指定字符的位置int index = sequenceString.indexOf('a');if (index != -1) {System.out.println("字符 'a' 的位置：" + index);} else {System.out.println("字符 'a' 不在字符串中！");}// 替换字符串中的指定字符String replacedString = sequenceString.replace('a', 'b');System.out.println("替换后的字符串：" + replacedString);}}```五、实验结果与分析1. 创建顺序串成功；2. 判断字符串为空、空串和空格；3. 获取字符串长度；4. 遍历字符串，打印每个字符；5. 查找字符串中指定字符的位置；6. 替换字符串中的指定字符。
数据结构——串实践报告
成绩：实验报告课程名称：数据结构实践课实验项目：定长串存储方法姓名：专业：班级：学号：计算机科学与技术学院实验教学中心2017 年9月23日哈尔滨理工大学计算机科学与技术学院实验教学中心实验报告实验项目名称：串的定长存储表示方法一、实践目的：1.熟练掌握串的定长顺序存储表示方法。
2.利用串的基本操作实现相关算法。
二、实践内容：1.实现串的定长顺序存储表示的基本操作。
并用主程序进行多次验证。
2.设 s='abcdefghijk'、t='cde'为两个字符串，利用定长顺序存储结构的串操作，判断 t 是否为 s 的子串。
如果是，输出子串所在位置（第一个字符）。
编程实现。
3.已知三个字符串分别为 s=’ababababcaabcbcaaaaaa’，s1=’caab’, s2=’bcb ’。
利用所学字符串基本运算的函数得到结果串为： s3= ’caabcbcaaaaaacaaaaaa’。
编程实现。
三、实验用设备仪器及材料计算机四、实验原理及接线五、实验操作步骤//main4-1.cpp 检验 bo4-1.cpp 的主程序//c1.h ( 程序名 )#include<string.h>#include<ctype.h>#include<malloc.h> // malloc()等#include<limits.h> // INT_MAX 等#include<stdio.h> // EOF(=^Z或 F6),NULL#include<stdlib.h> // atoi()#include<io.h> // eof()哈尔滨理工大学计算机科学与技术学院实验教学中心实验报告#include<math.h> // floor(),ceil(),abs()#include<process.h> // exit()//#include<iostream.h> // cout,cin//函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1// #define OVERFLOW -2因为在 math.h 中已定义 OVERFLOW的值为 3,故去掉此行OK 等typedef int Status; // Status 是函数的类型 ,其值是函数结果状态代码，如typedef int Boolean; // Boolean 是布尔类型 ,其值是 TRUE或 FALSE//c4-1.h 串的定长顺序存储表示#define MAXSTRLEN 30 //用户可在 255 以内定义最大串长（ 1 个字节）typedef char SString[MAXSTRLEN+1]; // 0号单元存放串的长度// bo4-1.cpp 串采用定长顺序存储结构 (由 c4-1.h 定义 )的基本操作 (14 个) //SString 是数组，故不需引用类型。
数据结构排序实验报告
数据结构排序实验报告一、实验目的本次数据结构排序实验的主要目的是深入理解和掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序和归并排序，并通过实际编程和实验分析，比较它们在不同规模数据下的性能表现，从而为实际应用中选择合适的排序算法提供依据。
二、实验环境本次实验使用的编程语言为 Python 3x，开发环境为 PyCharm。
实验中使用的操作系统为 Windows 10。
三、实验原理1、冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。
它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
2、插入排序（Insertion Sort）插入排序是一种简单直观的排序算法。
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个数组有序。
3、选择排序（Selection Sort）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
4、快速排序（Quick Sort）通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
5、归并排序（Merge Sort）归并排序是建立在归并操作上的一种有效、稳定的排序算法，该算法是采用分治法(Divide and Conquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
四、实验步骤1、算法实现使用 Python 语言分别实现上述五种排序算法。
为每个算法编写独立的函数，函数输入为待排序的列表，输出为排序后的列表。
2、生成测试数据生成不同规模（例如 100、500、1000、5000、10000 个元素）的随机整数列表作为测试数据。
实验五 顺序串实验报告
课内实验报告学生姓名:巩柠1009290212 及学号：江博1009290216王浩0809290228 学院: 理学院班级: 信计102课程名称：数据结构实验题目:顺序串基本操作指导教师郭新辰教授姓名及职称：胡建平副教授刘力实验师2011年10月18日目录一、实验目的 (1)二、实验内容 (1)三、实验要点及说明 (1)四、实现方法 (1)五、实验结果 (2)六、源程序清单 (2)七、思考及总结 (6)一、实验目的1. 了解顺序串的结构特点及有关概念；2. 理解顺序串的存储结构；3. 掌握顺序串的基本操作算法二、实验内容建立顺序串，完成顺序串的基本操作：初始化、求串长、串赋值、串连接、求子串、串比较、字串定位、串插入、子串删除、串替换、串清空、串输出等。
三、实验要点及说明通过一些函数对顺序串进行初始化，复制，插入等操作四、实现方法运行环境C++ 6.0五、实验结果六、源程序清单#include<stdio.h>#define MaxSize 50typedef struct{char data[MaxSize]; //存放字符串int length; //字符串长度}SqString;//将一个字符串常量赋给串svoid StrAssign(SqString &s,char cstr[]){int i;for(i=0;cstr[i]!='\0';i++) //这个'\0'代表字符串结束标志,编译系统自动加上的s.data[i]=cstr[i];s.length=i;}//字符串的复制void StrCopy(SqString &s,SqString t)int i;for(i=0;i<t.length;i++)s.data[i]=t.data[i];s.length=t.length;printf("字符串复制成功了\n");}//判断字符串是否相等void StrEqual(SqString s,SqString t){int i,same=1;if(s.length!=t.length)same=0;else{for(i=0;i<s.length;i++)if(s.data[i]!=t.data[i]){same=0;break;}}if(same==0)printf("这两个字符串不相等\n");elseprintf("这两个字符串相等\n");}//字符串的长度void StrLength(SqString s){printf("此字符串长度为：%d\n",s.length); }//合并字符串SqString Concat(SqString s,SqString t){SqString str;int i;str.length=s.length+t.length;for(i=0;i<s.length;i++)str.data[i]=s.data[i];for(i=0;i<t.length;i++)str.data[s.length+i]=t.data[i];return str;//求子字符串void SubStr(SqString s,int i,int j){SqString str;int k;str.length=0;if(i<=0||i>s.length||j<0||i+j-1>s.length)printf("子字符串复制失败\n");for(k=i-1;k<i+j-1;k++)str.data[k-i+1]=s.data[k];str.length=j;printf("子字符串复制成功长度为：%d\n",j); printf("下面输出此子字符串：\n");for(i=0;i<j;i++)printf("%c",str.data[i]);printf("\n");}//插入字符串SqString InserStr(SqString s1,int i,SqString s2){int j;SqString str;str.length=0;if(i<=0||i>s1.length+1){printf("字符串插入失败\n");return str;}for(j=0;j<i-1;j++)str.data[j]=s1.data[j];for(j=0;j<s2.length;j++)str.data[i-1+j]=s2.data[j];for(j=i-1;j<s1.length;j++)str.data[s2.length+j]=s1.data[j];str.length=s1.length+s2.length;printf("插入字符串成功长度为：%d\n",str.length); return str;}//删除字符串SqString DeleStr(SqString s,int i,int j){int k;SqString str;str.length=0;if(i<=0||i>s.length||i+j>s.length+1){printf("字符串删除失败\n"); return str;}for(k=0;k<i-1;k++)str.data[k]=s.data[k];for(k=i+j-1;k<s.length;k++)str.data[k-j]=s.data[k];str.length=s.length-j;printf("删除子字符串成功剩余长度为：%d\n",str.length); return str;}//替换字符串void RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.length=0;if(i<=0||i>s.length||i+j-1>s.length)printf("字符串替换失败了\n");for(k=0;k<i-1;k++)str.data[k]=s.data[k];for(k=0;k<t.length;k++)str.data[i+k-1]=t.data[k];for(k=i+j-1;k<s.length;k++)str.data[t.length+k-j]=s.data[k];str.length=s.length-j+t.length;printf("替换字符串成功新字符串长度为：%d\n",str.length); }//字符串的输出void DispStr(SqString s){int i;if(s.length>0){printf("下面输出这个字符串\n");for(i=0;i<s.length;i++)printf("%c",s.data[i]);printf("\n");}elseprintf("目前空字符串无法输出\n");}void main(){SqString s;char a[]={"boshi"}; //字符串常量aStrAssign(s,a);DispStr(s);StrLength(s);SqString s1,s2,t; //s1是待复制的字符串变量printf("请输入一个字符串t:\n");scanf("%s",t.data);StrAssign(t,t.data);StrCopy(s1,t); //复制字符串StrLength(s1);DispStr(s1);printf("下面判断字符串s1和字符串s是否相等\n");StrEqual(s,s1);printf("下面将字符串s1和字符串s合并一起\n");SqString str;str=Concat(s,s1); //合并字符串DispStr(str);StrLength(str);SubStr(str,22,7); //求子字符串str=DeleStr(str,15,4); //删除字符串DispStr(str);StrLength(str);printf("请插入一个字符串s2\n");scanf("%s",s2.data);StrAssign(s2,s2.data);str=InserStr(str,15,s2); //插入字符串DispStr(str);StrLength(str);printf("顺序字符串的基本运算到此结束了\n");}七、思考及总结对顺序串的基本操作有了一定的了解，在程序方面还有不懂的地方。
数据结构顺序串基本操作实验报告
在串s中,将所有出现的子串s1均替换成s2。
（10）输出串DispStr(s)
输出串s的所有元素值
（11）判断串是否为空IsEmpty(s)
为空返回1，不为空返回0
编写主函数
调用上述函数实现下列操作：
（1）建立串s=“abcdefghijklmn”，串s1=“xyz”，串t＝“hijk”
str.ch[k]=s.ch[k];
for(k=0;k<t.length;k++)
str.ch[i+k-1]=t.ch[k];
for(k=i+j-1;k<s.length;k++)
str.ch[t.length+k-j]=s.ch[k];
str.length=s.length-j+t.length;
char ch1[]="abcdefghijklmn",ch2[]="xyz",ch3[]="hijk";
SqString s,s1,s2,s3,s4,s5,s6,t,t1,t2;
int longth,same,kong;
StrAssign(s,ch1); //建立串s="abcdefghijklmn"
int k;
str.length=0;
if(i<=0||i>s.length||j<0||i+j-1>s.length)
return str;
for(k=i-1;k<i+j-1;k++)
str.ch[k-i+1]=s.ch[k];
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
}
return(same);
}
int StrLength(SqString s)//计算串长度
(
return(s.length);
}
SqString Concat(SqString s,SqString t)〃串连接
(
int i;
str.length=s.length+t.length;
for(i=0;i<s.length;i++)
(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的第2个字符开始的10个字符而产生串s5,并输出s5
(7)将串s1和串t连接起来而产生串s4,并输出s4
if(i<=0||i>s.length||j<0||i+j-1>s.length)
return str;
for(k=i-1;k<i+j-1;k++)
str.ch[k-i+1]=s.ch[k];
str.length=j;
return str;
}
SqString InsStr(SqString s1,int i,SqString s2)〃插入{
(9)串替换Rep所有出现的子串s1均替换成s2。
(10)输出串DispStr(s)
输出串s的所有元素值
(11)判断串是否为空IsEmpty(s)
为空返回1,不为空返回0
编写主函数
调用上述函数实现下列操作：
(1)建立串s= "abcdefghijklmn ",串s1= "xyz"，串t= " hijk "
if(i<=0||i>s.length||i+j>s.length+1) return str;
for(k=0;k<i-1;k++)
str.ch[k]=s.ch[k];
for(k=i+j-1;k<s.length;k++) str.ch[k-j]=s.ch[k];
str.length=s.length-j;
(
int i;
for(i=0;t[i]!='\0';i++)
s.ch[i]=t[i];
s.length=i;
}
void StrCopy(SqString &s,SqString t)〃串复制
(
int i;
for(i=0;i<t.length;i++)
s.ch[i]=t.ch[i];
s.length=t.length;
return str;
}
SqString RepStr(SqString s,int i,int j,SqString t)//替换
{
int k;
SqString str;
str.length=0;
if(i<=0||i>s.length||i+j-1>s.length)
(7)插入InsStr (s,i,t)
将串t插入到串s的第i(1 vi< StrLength(s)+1)个字符中，即将t的第一个字符作为s的 第i个字符，并返回产生的新串
(8)串删除DelStr (s,i,j)
从串s中删去从第i(1 vi< StrLength(s))个字符开始的长度为j的子串，并返回产生新串。
int j;
SqString str;
str.length=0;
if(i<=0||i>s1.length+1)
return str;
for(j=0;j<i-1;j++)
str.ch[j]=s1.ch[j];
for(j=0;j<s2.length;j++)
str.ch[i+j-1]=s2.ch[j];
str.ch[i]=s.ch[i];
for(i=0;i<t.length;i++)
str.ch[s.length+i]=t.ch[i];
return str;
}
SqString SubStr(SqString s,int i,int j)//求子串
{
SqString str;
int k;
str.length=0;
}
int StrEqual(SqString s,SqString t) //判断串相等(
int same=1,i;
if(s.length!=t.length)(
same=0;
}
else(
for(i=0;i<s.length;i++)
if(s.ch[i]!=t.ch[i])(
same=0;
break;
(8)比较串s1和s5是否相等，输出结果
(9)判断s3是否为空
四
#include<stdio.h>
#define MAX 100
typedef struct
(
char ch[MAX];
int length;
} SqString;
void StrAssign(SqString &s,char t[])//串赋值
编写串的基本操作函数
顺序串类型定义如下所示：
typedef struct (
char ch[MAX];
int length;
} 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 vi< StrLength(s))个字符开始的、由连续j个字符组成的子串。
for(j=i-1;j<s1.length;j++)
str.ch[s2.length+j]=s1.ch[j];
str.length=s1.length+s2.length;
return str;
}
SqString DelStr(SqString s,int i,int j) //删除
{
int k;
str.length=0;
数据结构实验报告
专业班级
学 号
一
1)熟悉串的定义和串的基本操作。
2)掌握顺序串的基本运算。
3)加深对串数据结构的理解，逐步培养解决实际问题的编程能力。
二
装有Visual C + + 6.0的计算机。
本次实验共计2学时。
三
编写一个程序，实现 顺序串的各种基本运算，并在此基础上设计一个主程序。具体如下: