数据结构-串的存储表示及基本操作_-课程设计-实验报告

合集下载

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

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

实验日期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、连接操作成功实现,输出了正确连接后的字符串。

数据结构串的实验报告

数据结构串的实验报告

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

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

串的数据结构实验报告

串的数据结构实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实训实验报告

数据结构实训实验报告

一、实验背景数据结构是计算机科学中一个重要的基础学科,它研究如何有效地组织和存储数据,并实现对数据的检索、插入、删除等操作。

为了更好地理解数据结构的概念和原理,我们进行了一次数据结构实训实验,通过实际操作来加深对数据结构的认识。

二、实验目的1. 掌握常见数据结构(如线性表、栈、队列、树、图等)的定义、特点及操作方法。

2. 熟练运用数据结构解决实际问题,提高算法设计能力。

3. 培养团队合作精神,提高实验报告撰写能力。

三、实验内容本次实验主要包括以下内容:1. 线性表(1)实现线性表的顺序存储和链式存储。

(2)实现线性表的插入、删除、查找等操作。

2. 栈与队列(1)实现栈的顺序存储和链式存储。

(2)实现栈的入栈、出栈、判断栈空等操作。

(3)实现队列的顺序存储和链式存储。

(4)实现队列的入队、出队、判断队空等操作。

3. 树与图(1)实现二叉树的顺序存储和链式存储。

(2)实现二叉树的遍历、查找、插入、删除等操作。

(3)实现图的邻接矩阵和邻接表存储。

(4)实现图的深度优先遍历和广度优先遍历。

4. 算法设计与应用(1)实现冒泡排序、选择排序、插入排序等基本排序算法。

(2)实现二分查找算法。

(3)设计并实现一个简单的学生成绩管理系统。

四、实验步骤1. 熟悉实验要求,明确实验目的和内容。

2. 编写代码实现实验内容,对每个数据结构进行测试。

3. 对实验结果进行分析,总结实验过程中的问题和经验。

4. 撰写实验报告,包括实验目的、内容、步骤、结果分析等。

五、实验结果与分析1. 线性表(1)顺序存储的线性表实现简单,但插入和删除操作效率较低。

(2)链式存储的线性表插入和删除操作效率较高,但存储空间占用较大。

2. 栈与队列(1)栈和队列的顺序存储和链式存储实现简单,但顺序存储空间利用率较低。

(2)栈和队列的入栈、出队、判断空等操作实现简单,但需要考虑数据结构的边界条件。

3. 树与图(1)二叉树和图的存储结构实现复杂,但能够有效地表示和处理数据。

数据结构串实验报告

数据结构串实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构-顺序串基本操作实验报告

数据结构-顺序串基本操作实验报告

数据结构\顺序串基本操作实验报告实验报告数据结构\顺序串基本操作一、实验目的本实验旨在通过实践,掌握顺序串的基本操作,包括顺序串的初始化、销毁、插入、删除和查找等。

二、实验内容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)返回相等元素的位置。

四、实验结果与分析根据实验步骤,我们可以完成顺序串的初始化、销毁、插入、删除和查找等基本操作。

通过这些操作,我们可以对顺序串进行各种元素的插入、删除和查找操作,方便实现顺序串的各种功能。

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

串的存储实验报告(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. 创建串、复制串、连接串等操作均能正常进行,验证了串的存储和操作的正确性。

串的数据结构实验报告

串的数据结构实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构串的实验报告

数据结构串的实验报告

一、实验目的1. 理解串的定义、性质和操作;2. 掌握串的基本操作,如串的创建、复制、连接、求子串、求逆序、求长度等;3. 熟练运用串的常用算法,如串的模式匹配算法(如KMP算法);4. 培养编程能力和算法设计能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 串的创建与初始化2. 串的复制3. 串的连接4. 串的求子串5. 串的求逆序6. 串的求长度7. 串的模式匹配算法(KMP算法)四、实验步骤1. 串的创建与初始化(1)创建一个串对象;(2)初始化串的长度;(3)初始化串的内容。

2. 串的复制(1)创建一个目标串对象;(2)使用复制构造函数将源串复制到目标串。

3. 串的连接(1)创建一个目标串对象;(2)使用连接函数将源串连接到目标串。

4. 串的求子串(1)创建一个目标串对象;(2)使用求子串函数从源串中提取子串。

5. 串的求逆序(1)创建一个目标串对象;(2)使用逆序函数将源串逆序。

6. 串的求长度(1)获取源串的长度。

7. 串的模式匹配算法(KMP算法)(1)创建一个模式串对象;(2)使用KMP算法在源串中查找模式串。

五、实验结果与分析1. 串的创建与初始化实验结果:成功创建了一个串对象,并初始化了其长度和内容。

2. 串的复制实验结果:成功将源串复制到目标串。

3. 串的连接实验结果:成功将源串连接到目标串。

4. 串的求子串实验结果:成功从源串中提取了子串。

5. 串的求逆序实验结果:成功将源串逆序。

6. 串的求长度实验结果:成功获取了源串的长度。

7. 串的模式匹配算法(KMP算法)实验结果:成功在源串中找到了模式串。

六、实验总结通过本次实验,我对串的定义、性质和操作有了更深入的了解,掌握了串的基本操作和常用算法。

在实验过程中,我遇到了一些问题,如KMP算法的编写和调试,但在老师和同学的指导下,我成功地解决了这些问题。

数据结构课程实验报告

数据结构课程实验报告

数据结构课程实验报告数据结构课程实验报告引言:数据结构是计算机科学中非常重要的一门课程,它研究了数据的组织、存储和管理方法。

在数据结构课程中,我们学习了各种数据结构的原理和应用,并通过实验来加深对这些概念的理解。

本文将对我在数据结构课程中的实验进行总结和分析。

实验一:线性表的实现与应用在这个实验中,我们学习了线性表这种基本的数据结构,并实现了线性表的顺序存储和链式存储两种方式。

通过实验,我深刻理解了线性表的插入、删除和查找等操作的实现原理,并掌握了如何根据具体应用场景选择合适的存储方式。

实验二:栈和队列的实现与应用栈和队列是两种常见的数据结构,它们分别具有后进先出和先进先出的特点。

在这个实验中,我们通过实现栈和队列的操作,加深了对它们的理解。

同时,我们还学习了如何利用栈和队列解决实际问题,比如迷宫求解和中缀表达式转后缀表达式等。

实验三:树的实现与应用树是一种重要的非线性数据结构,它具有层次结构和递归定义的特点。

在这个实验中,我们学习了二叉树和二叉搜索树的实现和应用。

通过实验,我掌握了二叉树的遍历方法,了解了二叉搜索树的特性,并学会了如何利用二叉搜索树实现排序算法。

实验四:图的实现与应用图是一种复杂的非线性数据结构,它由节点和边组成,用于表示事物之间的关系。

在这个实验中,我们学习了图的邻接矩阵和邻接表两种存储方式,并实现了图的深度优先搜索和广度优先搜索算法。

通过实验,我深入理解了图的遍历方法和最短路径算法,并学会了如何利用图解决实际问题,比如社交网络分析和地图导航等。

实验五:排序算法的实现与比较排序算法是数据结构中非常重要的一部分,它用于将一组无序的数据按照某种规则进行排列。

在这个实验中,我们实现了常见的排序算法,比如冒泡排序、插入排序、选择排序和快速排序等,并通过实验比较了它们的性能差异。

通过实验,我深入理解了排序算法的原理和实现细节,并了解了如何根据具体情况选择合适的排序算法。

结论:通过这些实验,我对数据结构的原理和应用有了更深入的理解。

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

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

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

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

数据结构 串 实验报告

数据结构 串 实验报告

数据结构串实验报告实验目的· 了解串的定义和性质· 掌握串的基本操作· 理解串的存储结构及其实现方法实验原理串是由零个或多个字符组成的有限序列。

也可以叫字符串。

如果串中每个字符的位置唯一确定,则称该串为定长串。

现实中大部分字符串是不定长的,为了便于存储和使用,通常将字符串存储成一段连续的内存空间,并在字符串末尾添加一个结束标志,用于表示字符串结束的位置。

串的基本操作包括:串赋值、串求长、串比较、串连接、串子串、串插入和串删除等。

串的存储结构有两种实现方法:顺序存储和链式存储。

顺序存储是将一个串存储在一段连续的内存区域中,而链式存储是将一个串存储在若干个节点中,每个节点中都保存着一个或多个字符。

链式存储的优点是灵活性高,插入和删除操作比顺序存储更容易实现。

但顺序存储是更为常用的实现方法,主要原因是顺序存储对于查找操作更加高效。

实验内容在链式存储方式中,使用一个链表节点表示一个字符,节点包含一个数据域和一个指向下一个节点的指针。

在串连接的操作中,需要对一个链表进行遍历,找到链表的末尾,然后将另一个链表拼接在后面,这个过程中需要修改相应节点的指针。

在串子串、串插入和串删除的操作中,需要遍历链表,找到相应的位置进行操作。

在顺序存储方式中,使用一个数组存储一个串,需要在数组的最后一个位置添加一个结束标志,用来表示串的结束。

在串连接的操作中,需要使用循环将一个串复制到另一个串的后面,同时更新结束标志。

在串子串、串插入和串删除的操作中,需要将数组中的元素进行移动,并更新结束标志。

实验结果串的基本操作都能够成功实现,并且能够在顺序存储和链式存储两种方式中进行操作。

实现过程中需要注意细节,例如顺序存储中需要将数组最后一个位置留给结束标志,链式存储中需要注意指针的修改等。

1. 串是由零个或多个字符组成的有限序列,在实际应用中经常用到。

3. 串的存储结构有两种实现方法:顺序存储和链式存储。

数据结构实验报告-串

数据结构实验报告-串

实验四串【实验目的】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串的模式匹配算法。

数据结构——串实践报告

数据结构——串实践报告

成绩:实验报告课程名称:数据结构实践课实验项目:定长串存储方法姓名:专业:班级:学号:计算机科学与技术学院实验教学中心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 是数组,故不需引用类型。

串的基本操作演示实验报告

串的基本操作演示实验报告

串的基本操作演示实验报告学号:姓名:班级:一.实验环境问题描述:如果语言没有把串作为一个预先定义好的基本类型对待,又需要用该语言写一个涉及串操作的软件系统时,用户必须自己实现串类型。

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

基本要求: 在教科书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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
7). .求字符串的置换:这个函数中有四个形参,两个字符串 s 和 t,两 个整形形参 i 和 j,在函数内部还要定义五个整形变量 k=0、l、n、m、p。首 先把 i+j 赋值给 l;通过输入输入主字符串和要置换的字符串的长度、主字符 串和要置换的字符串 s 和 t。先要判断 j 和将要被置换的字符串的串长关系, 如果刚好相等,就让 t 从第一个元素开始,s 从第第 i 个元素开始,一一赋值。 如 果 t 的 串 长 比 较 大 , 则 用 一 个 for 循 环 , for''(k=s->curlen;k>=i+j-1;k++)'',s[k]赋值给 s[k-j+t->scurlen],这样 剩余的空间刚好可以用来存放 t 的,同样的,如果 t 的串长比较小,同样用 以 for 循 环 , ''for(k=i+j-1,m=i;s[k]!='\0';k++,m++)'',s[k] 赋 值 给 s[m+t->curlen-1],s 剩余的空间也刚好用来存放 t 的。然后,把 t 中的元素 对应的赋值给 s。最后,在 s 的最后一个元素后赋值一个'\0',这时的 s,就 是 t 置换后的新的字符串。 8).子串的定位:这个函数有两个形参,s 和 t,在函数内部,还要定义两个整形变量 i=0 和 j=0。用 while 语句'' while((i<s->curlen)&&(j<t->curlen))'',满足条件 后进行的操作是检验对应的 s 和 t 的元素是否相等,相等时就 i++,j++,用 i 减去 t 的串长即为 t 作为子串在 s 中的定位位置。不相等时,就用 i 减去 j 加上 1 赋值给 i, j=0,往下扫描时,就从 t 的第一个元素再接着扫描。 9)主函数:在主函数中,因为要最多输入两个字符串,所以要先定义两个字符串 s 和 t。有的主函数需要用到整形的变量,最多是两个,所以也要定义两个整形变量 k 和 m。 函数中,有很多的功能不同的函数,这样就要求验证很多次,所以在这里我们考虑用
指导教师: 年月日
2
目录
第一章 数据结构课程设计的目的、基本要求及其解析...................................................1 1.课程设计的目的:......................................................................................................1 2.课程设计要求:..........................................................................................................1 3.课程设计题目解析:..................................................................................................1
#include<stdio.h> #include<string.h> #define maxsize 32 /*假设串可能的最大长度是 32*/ typedef struct {
char ch[maxsize]; /*串的存储空间*/ int curlen; /*当前串的长度*/ }seqstring; seqstring *s; void strcats() /*串的联接*/ { seqstring str1[32],str2[32]; printf("请输入两串字符串:"); /*输入两串字符串*/ scanf("%s%s",str1,str2); /*接受输入的字符串*/ strcat(str1,str2); /*联接两个字符串*/ puts(str1); /*输出联接后的字符串*/ } void strcmps() /*比较字符串的大小*/ { seqstring str1[32],str2[32]; printf("请输入两串字符串:"); scanf("%s%s",str1,str2); if(strcmp(str1,str2)>0)
第一章 数据结构课程设计的目的、基本要求及其解析
1.课程设计的目的: (1):掌握串的基本存储结构。 (2):掌握串的基本运算及其实现。 2.课程设计要求: (1):将上机程序全部调试通过。 (2):结合程序分析运行结果。 3.课程设计题目解析:
顾名思义,串及其基本操作,就是要在理解串的基本概念和特征的基础上, 了解串的内部表示和处理方法。这样才能有效地实现串的基本操作。串,也还是字符 串,是一种特殊的线性表。特殊之处在于表中的每一个元素都是字符,以及由此而要 求的一些特殊操作。在串及其基本操作中,要求的操作有联接、求串长、求子串、比 较串的大小、串的插入、串的删除、子串的定位和置换。因为所要进行的操作比较零 散也比较多,所以就要用到多个函数把这个整体的课程设计划分成多个模块来进行。 每个函数对应一个功能。在主函数中,用一个菜单,就可以将原来的已分模块的函数 系统地进行检验及操作。在程序设计的过程中,根据课程设计的目的和基本要求,注 意一些容易出错的地方及问题。
年级专业
姓名
成绩
1、课题设计目的: (1):掌握串的基本存储结构; (2):掌握串的基本运算及其实现; 2、课题设计意义:通过此次对于串及其基本操作的课程设计,更深层次 课题设计 的了解串的基本概念、特征,掌握串的基本存储结构、基本运算及其实现。 目的与 根据课程设计的目的和基本要求,注意一些容易发生错误的问题,从而进 设计意义 一步的认真分析问题、总结结论和经验,理解设计的思想和构思。联系到 生活上的实际问题,培养课程设计的能力及思想构思。
2
菜单来实现。用一个 while 循环,循环的条件为永真,这样当做完一个函数的验证时, 系统就会自动让你接着选择。在 while 循环下,输入一个数字。每个数字代表不同的 功能。然后用一个 switch 语句,不同的 case 对应不同的函数,如:case(0)就可 以代表求字符串的串长。 2.程序设计代码:
第四章 总结.........................................................................................................................12 4.1 思考和小结:........................................................................................................12 4.2 参考文献:............................................................................................................13
第二章 程序设计内容 1.程序设计的基本思想:(对于串及其基本操作中,程序被分割为很多的模块。所以 以下的程序设计业分成好几个方面来一一阐述) 1). 字符串的联接:在该函数中,strcat(str1,str2)就是将串 str2 紧接着放在 串 str1 的串值的末尾,组成一个新的串 str1。最后所得的新的 str1 即为所求的原来 的两个字符 str1 和 str1 的联接后的结果。输出即是。 2).比较两个字符串的大小:在该函数中,strcmp(str1,str2)是一个函数,它的 功能是比较两个串 str1 和 str2 的大小,通过 if 语句的判断函数 strcmp(str1,str2) 的函数值大小,其中函数值小于、等于和大于 0 时,分别表示 str1<str2、str1=str2、 str1>str2,其对应的输出结果分别为-1、0、1。 3)求字符串的串长:在该函数中,要先定义一个整形变量 i,strlen(str)表示字符 串 str 的长度,它是一个整形函数。通过函数 strlen(str)来算出字符串的长度, 然后赋值给整形变量 i 输出,从而 i 的值即为所求的字符串的长度。 4). 串的复制:在该函数中,首先分别输入两串字符串 str1 和 str2,通过函数 strcpy (str1,str2)来实现 str2 复制给 str1 的功能,得到复制后的字符串为新的 str1, 输出即为复制后的结果。
第二章 程序设计内容...........................................................................................................1 1.程序设计的基本思想................................................................................................1 2.程序设计代码:............................................................................................................3 3.程序运行结果:........................................................................................................8
第三章 程序设计的优缺点及遇到的问题.........................................................................12 3.1:课程设计的优缺点:..........................................................................................12 3.2 遇到的问题:........................................................................................................12
相关文档
最新文档