数据结构实验报告3--链串
数据结构3-串及其应用.

实验3:串及其应用一、实验目的掌握串类型的实现方法和文本模式匹配方法,熟悉一般文字处理软件的设计方法。
二、问题描述全屏幕文本编辑器通过终端对文本文件进行创建、插入、删除、修改、存储等操作。
用户可完成对文本的插入、删除、修改等功能。
三、实验要求1、对光标实现如下操作:上、下、左、右移动一个字符位置;向前、后翻页;光标移至文件首、尾;光标移至本行首、尾。
2、实现基本编辑命令:I----在当前光标前插入内容,按ESC结束F----在当前光标后插入内容,按ESC结束D----删除光标所在行ND---删除光标位置开始的n行N-----删除光标上的字符W----将修改后的文本保存下来Q----退出编辑状态。
四、实验环境PC微机DOS操作系统或Windows 操作系统Turbo C 程序集成环境或Visual C++ 程序集成环境五、实验步骤1、在内存开辟可容纳80行大小的编辑工作区和buffer 的修改缓冲区。
2、要求用户输入编辑文件名,对读入的文件建立相应的页表和行表,在文本编辑程序中设立页指针、行指针、字符指针,分别指示当前操作的页、行、字符。
3、执行插入、删除、修改操作时,将本次操作内容放到缓冲区;4、操作确定后,将修改后的文本存到文件中。
六、测试数据自行设定。
七、实验报告要求实验报告应包括以下几个部分:1、问题描述;2、算法的设计描述;3、测试结果的分析与讨论。
4、设计与实现过程中的体会,进一步的改进设想。
5、实验总结。
八、思考题1、对命令格式非法等错误做严格检查和适当处理。
2、扩充编辑操作,如对某行进行串替换?。
数据结构 串 实验报告

实验报告实验名称:串实验目的:(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");}。
数据结构实验报告串

数据结构实验报告串数据结构实验报告串一、引言数据结构是计算机科学的基础,它研究数据的组织、存储和管理方式。
在本次实验中,我们将学习和实践一些常见的数据结构,如链表、栈和队列。
通过实验,我们将深入了解这些数据结构的特点、优势和应用场景。
二、链表链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表可以分为单向链表和双向链表两种类型。
在实验中,我们实现了一个简单的单向链表,并进行了一系列操作,如插入、删除和遍历。
通过实验,我们发现链表的插入和删除操作时间复杂度为O(1),这是因为链表的节点可以通过指针直接连接,而不需要移动其他节点。
然而,链表的缺点是访问节点的时间复杂度为O(n),因为我们需要从头节点开始遍历链表直到找到目标节点。
三、栈栈是一种后进先出(LIFO)的数据结构,它只允许在栈顶进行插入和删除操作。
在实验中,我们实现了一个简单的栈,并进行了一系列操作,如入栈、出栈和获取栈顶元素。
通过实验,我们发现栈的插入和删除操作时间复杂度为O(1),这是因为栈的元素只能在栈顶进行操作。
栈的应用场景很广泛,例如函数调用和表达式求值。
在函数调用中,每次函数调用时,会将函数的返回地址和局部变量等信息存储在栈中,以便函数执行完毕后可以返回到正确的位置。
四、队列队列是一种先进先出(FIFO)的数据结构,它允许在队尾插入元素,在队头删除元素。
在实验中,我们实现了一个简单的队列,并进行了一系列操作,如入队、出队和获取队头元素。
通过实验,我们发现队列的插入和删除操作时间复杂度为O(1),这是因为队列的元素只能在队头和队尾进行操作。
队列的应用场景很多,例如任务调度和消息传递。
在任务调度中,每个任务都会被加入到队列中,然后按照先后顺序执行,确保任务按照正确的顺序完成。
五、实验总结通过本次实验,我们深入了解了链表、栈和队列这些常见的数据结构。
我们学习了它们的特点、优势和应用场景,并通过实践掌握了它们的基本操作。
C语言数据结构----链栈实验报告

#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int elemtype;typedef struct node{elemtype data;struct node *next;}node,*linkstack;linkstack *top;//链栈初始化node init_linkstack(){node top;top.next=NULL;return top;}//判栈空int linkstack_pankong(node top) {if(top.next==NULL)return 1;elsereturn 0;}//输出链栈元素void print_linkstack(node *top) {node *p;for(p=top->next;p;p=p->next){printf("%d\t",p->data);}}//入栈void puts_link(node *top,int a){node *p;p=(node *)malloc(sizeof(node));if(p==NULL){}else{p->data=a;p->next=top->next;top->next=p;}}//链栈逆序node nixu_link(node *a){node s,*r;s=init_linkstack();for(r=a->next;r;r=r->next){puts_link(&s,r->data);}return s;}//主函数部分void main(){elemtype x,i,n,a;node top;srand((unsigned)time(NULL));/*初始化链栈*/top=init_linkstack();printf("申请链栈内存空间成功\n");elemtype t;do{printf("\n\t请选择以下选项:\n\t1.生成链栈且输出\n\t2.将链栈逆序输出\n\t0.退出程序\n");printf("请输入对应选项:");scanf("%d",&t);switch(t){case 1:{printf("请输入需要生成随机数的数量: ");scanf("%d",&n);for(i=0;i<n;i++){a=rand()%50;puts_link(&top,a); //调用入栈函数,将随机数入栈}printf("链栈当前内容如下:\n");print_linkstack(&top);}continue;case 2:{if(linkstack_pankong(top)){printf("当前链栈内容是空的!");continue;}printf("链栈逆序输出为:\n");top=nixu_link(&top);print_linkstack(&top);}continue;case 0:break;}}while(t!=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、连接操作成功实现,输出了正确连接后的字符串。
数据结构串实验报告

数据结构串实验报告实验报告课程数据结构实验名称实验三串学号姓名实验日期:实验三串实验目的:1. 熟悉串类型的实现方法,了解简单文字处理的设计方法;2. 熟悉C语言的字符和把字符串处理的原理和方法;3. 熟悉并掌握模式匹配算法。
实验原理:顺序存储结构下的关于字符串操作的基本算法。
模式匹配算法BF、KMP实验内容:4-19. 在4.4.3节例4-6的基础上,编写比较Brute-Force算法和KMP算法比较次数的程序。
4-20. 设串采用静态数组存储结构,编写函数实现串的替换Replace(S,start,T,V),即要求在主串S中,从位置start开始查找是否存在字串T。
若主串S中存在子串T,则用子串V替换子串T,且函数返回1;若主串S中不存在子串T,则函数返回0;并要求设计I am a student”,T=“student”,V=“teacher”。
主函数进行测试。
一个测试例子为:S=“程序代码:4-19的代码:/*静态存储结构*/typedef struct{char str[MaxSize];int length;}String;/*初始化操作*/void Initiate(String *S) {S->length=0;}/*插入子串操作 */int Insert(String *S, int pos, String T)/*在串S的pos位置插入子串T*/{int i;if(pos<0||pos>S->length){printf("The parameter pos is error!\n");return 0;}else if(S->length+T.length>MaxSize){printf("The space of the array is not enough!\n"); return 0;}else{for(i=S->length-1; i>=pos; i--)S->str[i+T.length]=S->str[i];/*依次后移数据元素*/for(i=0; i<T.length; i++)S->str[pos+i]=T.str[i]; /*插入*/S->length=S->length+T.length;/*产生新的串长度值*/return 1;}}/*删除子串操作 */int Delete(String *S, int pos, int len) /*删除串S的从pos位置开始长度为len的子串值*/{int i;if(S->length<=0){printf("No elements deleting!\n");return 0;}else if(pos<0||len<0||pos+len>S->length){printf("The parameters pos and len are not correct!\n"); return 0;}else{for(i=pos+len; i<=S->length-1; i++)S->str[i-len]=S->str[i];/*依次前移数据元素*/S->length=S->length-len;/*产生新的串长度值*/return 1;}}/*取子串操作 */int SubString(String S, int pos, int len, String *T)/*取串S的从pos位置开始长度为len的子串值赋给子串T*/ {int i;if(pos<0||len<0||pos+len>S.length){printf("The parameters pos and len are not correct!\n"); return 0;}else{for(i=0; i<=len; i++)T->str[i]=S.str[pos+i]; /*给子串T赋值*/T->length=len; /*给子串T的长度域赋值*/return 1;}}/*查找子串BF(Brute-Force)操作*/int BFIndex(String S, int start, String T)/*查找主串S从start开始的子串T,找到返回T在S中的开始字符下标,否则返回-1*/ {int i= start, j=0, v;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)v=i-T.length;elsev=-1;return v;}/*查找子串KMP(D.E.Knuth-J.H.Morris-V.R.Pratt)操作 */ int KMPIndex(String S, int start, String T, int next[])/*查找主串S从start开始的子串T,找到返回T在S中的首字符下标,*/ /*否则返回-1*//*数组Next中存放有模式串T的next[j]值*/{int i= start, j=0, v;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else if(j==0) i++;else j=next[j];}if(j==T.length)v=i-T.length;elsev=-1;return v;}/*求模式串next[j]值的操作 */void GetNext(String T, int next[])/*求子串T的next[j]值并存放于数组next中*/ {int j=1, k=0;next[0]=-1;next[1]=0;while(j<T.length){if(T.str[j]=T.str[k]){next[j+1]=k+1;j++;k++;}else if(k==0){next[j+1]=0;j++;}else k=next[k];}}/*查找子串BF(Brute-Force)算法累计次数 */int BFIndexC(String S, int start, String T)/*查找主串S从start开始的子串T,找到返回T在S中的开始字符下标,否则返回-1*/{int i= start, j=0, t=0;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else{i=i-j+1;j=0;}t++;}return t;}/*查找子串KMP(D.E.Knuth-J.H.Morris-V.R.Pratt)操作 */ int KMPIndexC(String S, int start, String T, int next[])/*查找主串S从start开始的子串T,找到返回T在S中的首字符下标,*/ /*否则返回-1*//*数组Next中存放有模式串T的next[j]值*/{int i= start, j=0, t=0;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else if(j==0)i++;else j=next[j];t++;}return t;}测试主函数:#include<stdio.h>#define MaxSize 100#include"SString.h"#include"BFandKMP.h"void main(void){String S={{"cddcdc"},6}, T={{"abcde"},5};String S1={{"aaaaaaaa"},8}, T1={{"aaaab"},5};String S2={{"aaaaaaaaaaaaaaaaad"},18}, T2={{"aaaab"},5};int next[20], count;count=BFIndexC(S,0,T);printf("从S中查找T的Brute-Force算法比较次数:%d\n",count); GetNext(T, next);count=KMPIndexC(S,0,T,next);printf("从S中查找T的KMP算法比较次数:%d\n",count);count=BFIndexC(S1,0,T1);printf("从S1中查找T1的Brute-Force算法比较次数:%d\n",count); GetNext(T1, next);count=KMPIndexC(S1,0,T1,next);printf("从S1中查找T1的KMP算法比较次数:%d\n",count);count=BFIndexC(S2,0,T2);printf("从S2中查找T2的Brute-Force算法比较次数:%d\n",count); GetNext(T2, next);count=KMPIndexC(S2,0,T2,next);printf("从S2中查找T2的KMP算法比较次数:%d\n",count);}4-20的部分代码:Replace函数:/* 从主串S中查找字串T,若存在,并用串V替换串T并返回1,否则,返回0*/ int Replace(String S,int start,String T,String V){int i,v;Initiate(&S);Initiate(&T);Initiate(&V);for(i=0; i<strlen(S.str); i++)S.length=S.length+1;for(i=0; i<strlen(T.str); i++)T.length=T.length+1;for(i=0; i<strlen(V.str); i++)V.length=V.length+1;i=BFIndex(S, 0, T);if (i!=-1){if(Delete(&S, i, T.length))Insert(&S, i, V);for(i=0; i<S.length; i++)printf("%c", S.str[i]);printf("\n");return v=1;}else{printf("主串S中不存在串T\n");return v=0;}}测试主函数:#define MaxSize 80#include<stdio.h>#include<string.h>#include "SString.h"int main(void){ int v;String S={"I am a student."}, T={"student"}, V={"teacher"}; v=Replace(S,0,T,V);printf("返回%d\n",v);}实验结果:4-19.程序调式结果:4-20.程序调式结果:总结与思考KMP算法的比较次数比Brute-Force算法的少。
数据结构——串实践报告
课程名称:数据结构实践课实验项目:定长串存储方法姓名:专业:班级:学号:计算机科学与技术学院实验教学中心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,故去掉此行typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等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是数组,故不需引用类型。
数据结构实验报告《三、串及其应用》
数据结构实验报告《三、串及其应用》时间:20XX年X月X日数据结构实验报告- - - - 串及其应用之文学研究助手【问题描述】文学研究人员需要统计某篇英文小说中某些单词(特别是形容词)的出现次数和位置,甚至连数字和标点符号的个数也可以统计。
试写一个实现这一目标的文字统计系统,称为“文学研究助手”。
【基本要求】1、输入一页文字,静态存储一页文章,每行最多不超过80个字符,共N行;2、分别统计出其中英文字母数、空格数、标点符号及整篇文章总字数;3、统计某一字符串在文章中出现的次数,并输出该次数;4、删除某一子串,并将后面的字符前移。
【运用拓展】1、保存输入文章到本地text文本中;2、模式匹配基于KMP算法;3、仿真友好界面显示:(1)、要求用菜单选择操作,分别用几个子函数实现相应的功能;(2)、输入数据的形式和范围:可以输入大写、小写的英文字母、任何数字及标点符号。
(3)、输出形式:1)、分行输出用户输入的各行字符;2)、分5行输出“全部字母数“、“数字个数“、“空格个数“、“标点符号个数”“文章总字数“;3)、输出删除某一字符串后的文章。
【涉及的知识点】链串的插入,删除,查找,模式匹配(knp算法)及文件的写入与写出,用switch,case语句进行菜单的选择,用while 语句进行循环,用if语句进行条件的判断等等。
【设计思路】、总体思路:本文采用链式存储字符串,链串的插入采用后插法,以‘#’ 为字符串结束的标志。
在插入字符串的同时用文件存储字符串。
、删除算法的基本思路:输入要删除的字符串,同样以‘#’结束,然后在文中查找该字符串,若找到了则把它删除,同时长度要减少;否则,没找到不能删除。
查找算法与删除算法类似;但也有不同之处,不同在于:这里是要查找某字符串在文中出现的次数,因此,当找到该字符串后还要继续往后查找,并将次数加1;直到文章的末尾才结束查找。
、用菜单做选择:用switch,case语句进行选择判断,并用类的对象调用类的成员函数以实现特定的功能。
串的存储实验报告(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. 创建串、复制串、连接串等操作均能正常进行,验证了串的存储和操作的正确性。
数据结构顺序串和链串实验报告
《数据结构》课程实验报告实验名称顺序串和链串实验序号 4 实验日期姓名院系班级学号专业指导教师成绩教师评语一、实验目的和要求(1)理解串和一般线形表之间的差异(2)重点掌握在顺序串上和链串上实现串的基本运算算法(3)掌握串的简单匹配算法和KMP算法(4)灵活运用串这种数据结构解决一些综合应用问题二、实验项目摘要编写一个程序algo4-1.cpp,实现顺序串的各种基本运算,并在此基础上设计一个主程序并完成如下功能:(1)建立串s=”abcdefghefghijklmn”和串sl=”xyz”;(2)输出串s;(3)输出串s的长度;(4)在串s的第9个字符位置插入串sl而产生串s2;(5)输出串s2;(6)删除串s的第2个字符开始的5个字符而产生的串s2;(7)输出串s2;(8)将串s的第2个字符开始的5个字符替换成串s1而产生串s2;(9)输出串s2;(10)提取串s的第2个字符开始的10个字符而产生串s3;(11)输出串s3;(12)将串s1和串s2连接起来而产生串s4;(13)输出串s4。
编写一个程序algo4-2.cpp,实现链串的各种基本运算,并在此基础上设计一个主程序并完成如下功能:(1)建立串s=”abcdefghefghijklmn”和串sl=”xyz”;(2)输出串s;(3)输出串s的长度;(4)在串s的第9个字符位置插入串sl而产生串s2;(5)输出串s2;(6)删除串s的第2个字符开始的5个字符而产生的串s2;(7)输出串s2;(8)将串s的第2个字符开始的5个字符替换成串s1而产生串s2;(9)输出串s2;(10)提取串s的第2个字符开始的10个字符而产生串s3;(11)输出串s3;(12)将串s1和串s2连接起来而产生串s4;(13)输出串s4。
三、实验预习内容顺序串的基本运算的算法(StrAssign(s,cstr),StrCopy(s,t),StrEquat(s,t),StrLength(s),Concat(s,t),SubStr (s,i,j),InsStr(s1,i,s2),DelStr(s,i,j),RepStr(s,i,j,t),DispStr(s))链串的基本运算的算法(StrAssign(s,cstr),StrCopy(s,t),StrEquat(s,t),StrLength(s),Concat(s,t),SubStr (s,i,j),InsStr(s1,i,s2),DelStr(s,i,j),RepStr(s,i,j,t),DispStr(s))三、实验结果与分析4-1#include <stdio.h>#define MaxSize 100typedef struct{ char data[MaxSize];int length;} SqString;void StrAssign(SqString &s,char cstr[]){ int i;for (i=0;cstr[i]!='\0';i++)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;}int StrEqual(SqString s,SqString t){ int same=1,i;if (s.length!=t.length)elsefor (i=0;i<s.length;i++)if (s.data[i]!=t.data[i]){ same=0;break;}return same;}int StrLength(SqString s){return 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;}SqString 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) return str;for (k=i-1;k<i+j-1;k++)str.data[k-i+1]=s.data[k];str.length=j;return str;}SqString InsStr(SqString s1,int i,SqString s2) { int j;SqString str;str.length=0;if (i<=0 || i>s1.length+1)for (j=0;j<i-1;j++)str.data[j]=s1.data[j];for (j=0;j<s2.length;j++)str.data[i+j-1]=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;return str;}SqString DelStr(SqString s,int i,int j){ int k;SqString str;str.length=0;if (i<=0 || i>s.length || i+j>s.length+1)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;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)return str;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;return str;}void DispStr(SqString s){ int i;if (s.length>0){for (i=0;i<s.length;i++)printf("%c",s.data[i]);printf("\n");}}int main(){SqString s,s1,s2,s3,s4;printf("建立串s='abcdefghefghijklmn'和串sl='xyz'\n");StrAssign(s,"abcdefghefghijklmn");StrAssign(s1,"xyz");printf("输出串s:");DispStr(s);printf("串s的长度:%d\n",StrLength(s));printf("在串s的第9个字符位置插入串sl而产生串s2\n");s2=InsStr(s,9,s1);printf("输出串s2:");DispStr(s2);printf("删除串s的第2个字符开始的5个字符而产生的串s2\n");s2=DelStr(s,2,5);printf("输出串s2:");DispStr(s2);printf("将串s的第2个字符开始的5个字符替换成串s1而产生串s2\n"); s2=RepStr(s,2,5,s1);printf("输出串s2:");DispStr(s2);printf("提取串s的第2个字符开始的10个字符而产生串s3\n");s3=SubStr(s,2,10);printf("输出串s3:");DispStr(s3);printf("将串s1和串s2连接起来而产生串s4\n");s4=Concat(s1,s2);printf("输出串s4:");DispStr(s4);}4-2#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char cstr[]){ int i;LiString *r,*p;s=(LiString * )malloc(sizeof(LiString));r=s;for (i=0;cstr[i]!='\0';i++){ p=(LiString * )malloc(sizeof(LiString));p->data=cstr[i];r->next=p;r=p;}r->next=NULL;}void StrCopy(LiString *&s,LiString *t){ LiString * p=t->next,*q,*r;s=(LiString * )malloc(sizeof(LiString));r=s;while (p!=NULL){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;}int StrEqual(LiString *s,LiString *t){ LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data) { p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){ int i=0;LiString *p=s->next;while (p!=NULL){ i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){ LiString *str,*p=s->next,*q,*r;str=(LiString * )malloc(sizeof(LiString));r=str;while (p!=NULL){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;return str;}LiString *SubStr(LiString *s,int i,int j){ int k;LiString *str,*p=s->next,*q,*r;str=(LiString * )malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) return str;for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;return str;}LiString *InsStr(LiString *s,int i,LiString *t) { int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString * )malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1)return str;for (k=1;k<i;k++){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}while (p1!=NULL){ q=(LiString * )malloc(sizeof(LiString));q->data=p1->data;r->next=q;r=q;p1=p1->next;}while (p!=NULL){q=(LiString *)malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;return str;}LiString *DelStr(LiString *s,int i,int j){ int k;LiString *str,*p=s->next,*q,*r;str=(LiString * )malloc(sizeof(LiString));r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) return str;for (k=0;k<i-1;k++){ q=(LiString *)malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++)p=p->next;while (p!=NULL){q=(LiString *)malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) return str;for (k=0;k<i-1;k++){q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++)p=p->next;while (p1!=NULL){q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL){q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){ LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int main(){LiString *s,*s1,*s2,*s3,*s4;printf("建立串s和串s1\n");StrAssign(s,"abcdefghefghijklmn");StrAssign(s1,"xyz");printf("输出串s:");DispStr(s);printf("串s的长度:%d\n",StrLength(s));printf("在串s的第9个字符位置插入串s1而产生串s2\n");s2=InsStr(s,9,s1);printf("输出串s2:");DispStr(s2);printf("删除串s第2个字符开始的5个字符而产生串s2\n");s2=DelStr(s,2,3);printf("输出串s2:");DispStr(s2);printf("将串s第2个字符开始的5个字符替换成串s1而产生串s2\n");s2=RepStr(s,2,5,s1);printf("输出串s2:");DispStr(s2);printf("提取串s的第2个字符开始的10个字符而产生串s3\n");s3=SubStr(s,2,10);printf("(输出串s3:");DispStr(s3);printf("将串s1和串s2连接起来而产生串s4\n");s4=Concat(s1,s2);printf("输出串s4:");DispStr(s4);}注:空间不够,可以增加页码。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
//判断字符串是否为空
void empstr(listring *s){
if(s->next==NULL)
printf("字符串是空的!");
else
printf("字符串不为空!");
}
void initstr(listring *&s){
s=(listring *)malloc(sizeof(listring));
(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)
返回由两个串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个字符,并返回产生的新串
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
while(p1!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p1->data;
q=(listring *)malloc(sizeof(listring));
q->data=p1->data;
r->next=q;
r=q;
p1=p1->next;
}
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
二、实验环境
装有Visual C++6.0的计算机。
三、实验内容
编写一个程序,实现链串的各种基本运算,并在此基础上设计一个主程序。具体如下:
编写栈的基本操作函数
链串类型定义如下所示:
typedef struct snode{
char data;
struct snode *next;
}listring;
strcopy(t1,t);
printf("输出t1的长度:%d\n",strlength(t1));
s2=insstr(s,9,s1);
printf("输出s2:\n");
dispstr(s2);
s3=delstr(s,2,5);
printf("输出s3:\n");
dispstr(s3);
s4=repstr(s,2,3,s1);
(6)提取串s的第8个字符开始的4个字符而产生串s5,并输出s5
(7)将串s1和串t连接起来而产生串s6,并输出s6
(8)比较串s1和s5是否相等,输出结果
程序清单:
#include<stdio.h>
#include<stdlib.h>
typedef struct snode{
char data;
struct snode *next;
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
r->next=NULL;
return str;
}
//字符串替换
listring *repstr(listring *s,int i,int j,listring *t){
str=(listring *)malloc(sizeof(listring));
str->next=NULL;
r=str;
if(i<=0||i>strlength(s)||j<0||i+j-1>strlength(s))
return str;
for(k=0;k<i-1;k++)
p=p->next;
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
r->next=NULL;
return str;
}
//字符串的子串
listring *substr(listring *s,int i,int j){
int k;
listring *str,*p=s->next,*q,*r;
r=str;
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
p=t->next;
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
listring *delstr(listring *s,int i,int j){
int k;
listring *str,*p=s->next,*q,*r;
str=(listring *)malloc(sizeof(listring));
str->next=NULL;
r=str;
if(i<=0||i>strlength(s)||j<0||i+j-1>strlength(s))
else
printf("s1与s5不相等!");
return 0;
}
运行结果:
四、实验心得与小结
这次上机的内容是实现链串的基本算法,跟前面学的链表的基本算法是差不多的,所以这次实验还是比较简单的,但也曾出现过一点点小问题,直接把字符串赋值给指针s="abcdefghijklmn";s1="xyz";t="hijk";结果出现如下错误:
int k;
listring *str,*p=s->next,*p1=t->next,*q,*r;
str=(listring *)malloc(sizeof(listring));
str->next=NULL;
r=str;
if(i<=0||i>strlength(s)||j<0||i+j-1>strlength(s))
r->next=q;
r=q;
p1=p1->next;
}
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
r->next=NULL;
return str;
}
//字符串删除
int k;
listring *str,*p=s->next,*p1=t->next,*q,*r;
str=(listring *)malloc(sizeof(listring));
str->next=NULL;
r=str;
if(i<=0||i>strlength(s)+1)
return str;
for(k=1;k<i;k++){
(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)
return str;
for(k=0;k<i-1;k++){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
for(k=0;k<j;k++)
p=p->next;
while(p1!=NULL){
r=s;
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
r->next=NULL;
}
//字符串长度
int strlength(listring *s){
int i=0;
listring *p=s->next;
while(p!=NULL){