数据结构实验报告3链串
宁波工程学院电信学院计算机教研室实验报告一、实验目的1)熟悉串的定义和串的基本操作。
2 )掌握链串的基本运算。
3 )加深对串数据结构的理解，逐步培养解决实际问题的编程能力。
二、实验环境装有Visual C ++ 6.0的计算机。
三、实验内容编写一个程序，实现链串的各种基本运算，并在此基础上设计一个主程序。
具体如下：编写栈的基本操作函数链串类型定义如下所示：typedef struct sno de{char data;struct snode *n ext;}listri ng;(1)串赋值Assig n(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 w i w StrLength(s))个字符开始的、由连续j 个字符组成的子串。
( 7)插入InsStr (s,i,t)将串t 插入到串s 的第i(1 w i w StrLength(s)+1) 个字符中,即将t的第一个字符作为s 的第i 个字符,并返回产生的新串( 8)串删除DelStr (s,i,j)从串s 中删去从第i(1 w i w StrLength(s)) 个字符开始的长度为j 的子串,并返回产生的新串。
(9)串替换RepStr (s,s1,s2)在串s 中,将所有出现的子串s1 均替换成s2 。
(10)输出串DispStr(s)输出串s 的所有元素值(11 )判断串是否为空IsEmpty(s)编写主函数调用上述函数实现下列操作：(1) 建立串s= “ abcdefghijklmn ”,串s1= “xyz ”,串t =" hijk ”( 2 ) 复制串t 到t1 ，并输出t1 的长度( 3) 在串s 的第9 个字符位置插入串s1 而产生串s2 ，并输出s2( 4) 删除s 第 2 个字符开始的 5 个字符而产生串s3 ，并输出s3( 5) 将串s 第 2 个字符开始的 3 个字符替换成串s1 而产生串s4 ，并输出s4(6) 提取串s的第8个字符开始的4个字符而产生串S5，并输出S5( 7) 将串s1 和串t 连接起来而产生串s6 ，并输出s6( 8) 比较串s1 和s5 是否相等，输出结果程序清单：#include<stdio.h>#include<stdlib.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 strlength(listring *s){int i=0;listring *p=s->next; while(p!=NULL){ i++; p=p->next;} return i;}// 判断字符串是否相等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;else return 0;}// 字符串连接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)); 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;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;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;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;}// 字符串输出void dispstr(listring *s){listring *p=s->next;while(p!=NULL){printf("%c",p->data); p=p->next;}printf("\n");}// 判断字符串是否为空void empstr(listring *s){if(s->next==NULL)printf(" 字符串是空的!");elseprintf(" 字符串不为空!");}void initstr(listring *&s){s=(listring *)malloc(sizeof(listring)); s->next=NULL;}// 主函数int main(void){listring *s,*s1,*t,*t1,*s2,*s3,*s4,*s5,*s6; int l;strassign(s,"abcdefghijklmn");strassign(s1,"xyz");strassign(t,"hijk");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);printf(" 输出s4:\n");dispstr(s4);s5=substr(s,8,4);printf(" 输出s5:\n");dispstr(s5);s6=concat(s1,t);printf(" 输出s6:\n");dispstr(s6);l=strequal(s1,s5);if(l==1)printf("s1 与s5 相等!");elseprintf("s1 与s5 不相等!");return 0;}运行结果：四、实验心得与小结这次上机的内容是实现链串的基本算法，跟前面学的链表的基本算法是差不多的，所以这次实验还是比较简单的，但也曾出现过一点点小问题，直接把字符串赋值给指针s="abcdefghijklmn"; s1="xyz"; t="hijk"; 结果出现如下错误：通过调用函数void strassign(listring *&s,char cstr[]) 将其订正为strassign(s,"abcdefghijklmn"); strassign(s1,"xyz"); strassign(t,"hijk"); 后没有错误；编译、组建都没有错误的情况下，s2 是在串s 的第9 个字符位置插入串s1 而产生的，本应出现的结果为可运行时却出现如下的结果查找了原因之后才发现在插入s1 数据时，都把s 的第九个字母的数据赋值给了s2 ，*p1=s1->next ；q->data=p->data;把错误改为q->data=p1->data; 后运行正确。
【精品】数据结构串实验报告
【精品】数据结构串实验报告
（仅校内可用）
本次实验是基于数据结构串的相关知识，设计、实现及实验关于串的操作，并要求我们编写综合性实验报告。
1、实验目的是了解串结构及其实现方法，并能够用有限的时间内完成实验。
2、实验要求：
（1）实现关于串的一组基本操作
（2）实现串的模式匹配算法
3、实验的进度：
（1）完成程序的设计，要求建立合理的数据结构，编写部分重要算法，调试程序；
（2）设计一组完整的数据，并完成所设计程序的测试；
（3）对串模式匹配算法和高效率算法的效率、正确性进行测试；
（4）完成实验总结，参加试验验收。
4、实验结果：
（1）建立了串的节点数据结构，并编写相关操作算法，经测试结果显示，程序的实现能做到正确、有效的运行；
（2）完成对串模式匹配算法和高效率算法的测试，匹配算法水平介于暴力及KMP算法之间，效率较高；高效率算法在重复部分采用滑动窗口技术，同时避免了重复移动结点带来的时间开销，效率较高且正确性得到了优化；
（3）完成了实验总结，并得出本次实验的结论：实现串的模式匹配算法和高效率算法能够较好地实现串的基本操作，同时具有较高的效率；
最后，在实验过程中，我收获颇丰，加深了对串结构及实现方法的理解，使我对数据结构有了更全面的认识。
实验三串基本操作的编程实现
实验三串基本操作的编程实现引言：串是由零个或多个字符组成的有限序列，是一种非常基础也非常重要的数据结构。
在本实验中，我们将学习串的基本操作，并使用C语言来实现这些操作。
1.实验目的：-掌握串的基本操作，包括串的初始化、判空、求长度、复制和拼接等操作；-学会使用C语言编程实现串的基本操作。
2.实验内容：本实验主要包括以下几个串的基本操作的编程实现。
2.1串的初始化操作在C语言中，我们可以使用字符数组来表示一个串。
以下是一个串的初始化操作的实现代码：```c#include <stdio.h>void InitString(char s[], char str[])int i;for (i = 0; str[i] != '\0'; i++)s[i] = str[i];}s[i]='\0';int maichar s[20];char str[] = "Hello, World!";InitString(s, str);printf("Initialized string: %s\n", s);return 0;```2.2串的判空操作判空操作即判断一个串是否为空串。
如果一个串的长度为0，则表示该串为空串。
以下是一个判空操作的实现代码示例：```c#include <stdio.h>#include <stdbool.h>bool IsEmptyString(char s[])return s[0] == '\0';int maichar s[20] = ""; // 空串if (IsEmptyString(s))printf("The string is empty.\n");} elseprintf("The string is not empty.\n");}return 0;```2.3串的长度操作求串的长度，即求一个串中字符的个数。
数据结构实验报告三
数据结构实验报告三数据结构实验报告三引言：数据结构是计算机科学中的重要内容之一，它研究的是如何组织和存储数据以便高效地访问和操作。
本实验报告将介绍我在数据结构实验三中的实验过程和结果。
实验目的：本次实验的主要目的是熟悉并掌握树这种数据结构的基本概念和操作方法，包括二叉树、二叉搜索树和平衡二叉树等。
实验内容：1. 实现二叉树的创建和遍历在本次实验中，我首先实现了二叉树的创建和遍历。
通过递归的方式，我能够方便地创建一个二叉树，并且可以使用前序、中序和后序遍历方法对二叉树进行遍历。
这些遍历方法的实现过程相对简单，但能够帮助我们更好地理解树这种数据结构的特点。
2. 实现二叉搜索树的插入和查找接下来，我实现了二叉搜索树的插入和查找操作。
二叉搜索树是一种特殊的二叉树，它的左子树上的节点的值都小于根节点的值，右子树上的节点的值都大于根节点的值。
通过这种特性，我们可以很方便地进行插入和查找操作。
在实现过程中，我使用了递归的方法，通过比较节点的值来确定插入的位置或者进行查找操作。
3. 实现平衡二叉树的插入和查找平衡二叉树是为了解决二叉搜索树在某些情况下可能会退化成链表的问题而提出的。
它通过在插入节点的过程中对树进行旋转操作来保持树的平衡。
在本次实验中，我实现了平衡二叉树的插入和查找操作。
通过对树进行左旋、右旋等操作，我能够保持树的平衡，并且能够在O(log n)的时间复杂度内进行插入和查找操作。
实验结果：通过本次实验，我成功地实现了二叉树、二叉搜索树和平衡二叉树的相关操作。
我编写了测试代码，并对代码进行了测试，结果表明我的实现是正确的。
我能够正确地创建二叉树，并且能够使用前序、中序和后序遍历方法进行遍历。
对于二叉搜索树和平衡二叉树，我能够正确地进行插入和查找操作，并且能够保持树的平衡。
实验总结：通过本次实验，我深入了解了树这种数据结构的特点和操作方法。
二叉树、二叉搜索树和平衡二叉树是树的重要应用，它们在实际开发中有着广泛的应用。
数据结构实验报告串
数据结构实验报告串《数据结构实验报告串》在数据结构课程中，实验报告是非常重要的一环。
通过实验报告，我们能够将课堂上学到的知识应用到实际中，加深对数据结构的理解和掌握。
本次实验报告串将介绍我们在数据结构实验中所进行的一系列实验，以及实验结果和分析。
实验一：数组和链表的比较在第一个实验中，我们对数组和链表进行了比较。
我们通过编写代码，分别实现了数组和链表的基本操作，包括插入、删除、查找等。
通过对比实验结果，我们发现在插入和删除操作中，链表的效率明显高于数组，而在查找操作中，数组的效率更高。
这说明在不同的场景下，数组和链表都有各自的优势和劣势。
实验二：栈和队列的应用在第二个实验中，我们学习了栈和队列的应用。
我们通过编写代码，实现了栈和队列的基本操作，并应用到实际问题中。
我们发现栈适合用于实现逆波兰表达式和括号匹配等问题，而队列适合用于实现广度优先搜索和模拟排队等问题。
这些实际应用让我们更加深入地理解了栈和队列的特点和用途。
实验三：树和图的遍历在第三个实验中，我们学习了树和图的遍历算法。
我们通过编写代码，实现了深度优先搜索和广度优先搜索算法，并应用到树和图的遍历中。
我们发现深度优先搜索适合用于解决迷宫问题和拓扑排序等问题，而广度优先搜索适合用于解决最短路径和连通性问题。
这些实验让我们更加深入地理解了树和图的遍历算法，以及它们在实际中的应用。
通过以上一系列实验，我们对数据结构的理论知识有了更深入的理解，同时也掌握了一些实际应用的技能。
实验报告串的编写过程也让我们更加熟练地掌握了数据结构的相关操作和算法。
希望通过这些实验，我们能够更好地应用数据结构知识，解决实际中的问题，提高编程能力和算法水平。
数据结构 串 实验报告
实验报告实验名称：串实验目的：（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");}。
数据结构实验报告实验总结
数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。
通过实验，我对这些数据结构的特点、操作和应用有了更深入的了解。
下面对每一部分实验进行总结。
实验一：线性表的基本操作线性表是一种常见的数据结构，本实验要求实现线性表的基本操作，包括插入、删除、查找、遍历等。
在实验过程中，我对线性表的结构和实现方式有了更清晰的认识，掌握了用数组和链表两种方式实现线性表的方法。
实验二：栈的应用栈是一种后进先出（LIFO）的数据结构，本实验要求利用栈实现简单的括号匹配和后缀表达式计算。
通过实验，我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算，有效地解决了对应的问题。
实验三：队列的应用队列是一种先进先出（FIFO）的数据结构，本实验要求利用队列实现银行排队和迷宫求解。
通过实验，我对队列的应用有了更加深入的了解，了解到队列可以解决需要按顺序处理的问题，如排队和迷宫求解等。
实验四：链表的应用链表是一种常用的数据结构，本实验要求利用链表实现学生信息管理系统。
通过实验，我对链表的应用有了更深入的了解，了解到链表可以方便地实现对于数据的插入、删除和修改等操作，并且可以动态地调整链表的长度，适应不同的需求。
通过本次实验，我掌握了线性表、栈、队列和链表的基本操作，并了解了它们的特点和应用方式。
同时，通过实际编程的过程，我对于数据结构的实现方式和效果有了更直观的认识，也锻炼了自己的编程能力和解决问题的能力。
在实验过程中，我遇到了一些问题，如程序逻辑错误和内存泄漏等，但通过调试和修改，最终成功解决了这些问题，对自己的能力也有了更多的信心。
通过本次实验，我深刻体会到了理论与实践的结合的重要性，也对于数据结构这门课程有了更加深入的理解。
总之，本次数据结构实验给予了我很多有益的启发和收获，对于数据结构的概念、特点和应用有了更深入的理解。
在以后的学习中，我会继续加强对数据结构的学习和研究，不断提高自己的编程能力和解决问题的能力。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说，我们需要实现一个树的数据结构，并对其进行插入、删除、查找等操作，同时还需要实现树的遍历算法，包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构，由结点和边组成。
树的每个结点都可以有多个子结点，但是每个结点只有一个父结点，除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中，我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树，每个结点最多只有两个子结点。
根据二叉树的特点，我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先，我们需要定义树的结点类，包括结点值、左子结点和右子结点。
然后，我们可以定义树的类，包括根结点和相应的操作方法，如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说，如果要插入的值小于当前结点的值，则将其插入到左子树中；如果要插入的值大于当前结点的值，则将其插入到右子树中。
如果当前结点为空，则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说，如果要删除的值小于当前结点的值，则在左子树中继续查找；如果要删除的值大于当前结点的值，则在右子树中继续查找。
如果要删除的值等于当前结点的值，则有三种情况：- 当前结点没有子结点：直接将当前结点置为空。
- 当前结点只有一个子结点：将当前结点的子结点替代当前结点。
- 当前结点有两个子结点：找到当前结点右子树中的最小值，将其替代当前结点，并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说，如果要查找的值小于当前结点的值，则在左子树中继续查找；如果要查找的值大于当前结点的值，则在右子树中继续查找。
串-数据结构实验报告
串-数据结构实验报告串数据结构实验报告一、实验目的本次实验的主要目的是深入理解和掌握串这种数据结构的基本概念、存储方式以及相关的操作算法。
通过实际编程实现串的基本操作，提高对数据结构的理解和编程能力，培养解决实际问题的思维和方法。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理（一）串的定义串是由零个或多个字符组成的有限序列。
在本次实验中，我们主要关注的是字符串。
（二）串的存储方式1、顺序存储定长顺序存储：使用固定长度的数组来存储字符串，长度不足时用特定字符填充。
堆分配存储：根据字符串的实际长度动态分配存储空间。
2、链式存储每个节点存储一个字符，并通过指针链接起来。
（三）串的基本操作1、串的创建和初始化2、串的赋值3、串的连接4、串的比较5、求子串6、串的插入和删除四、实验内容及步骤（一）顺序存储方式下串的实现1、定义一个结构体来表示顺序存储的字符串，包含字符数组和字符串的实际长度。
｀｀｀cppstruct SeqString ｛char str;int length;｝；｀｀｀2、实现串的创建和初始化函数｀｀｀cppSeqString createSeqString(const char initStr) ｛int len ＝ strlen(initStr)；SeqString s;sstr ＝ new charlen ＋ 1;strcpy(sstr, initStr)；slength ＝ len;return s;｝｀｀｀3、串的赋值函数｀｀｀cppvoid assignSeqString(SeqString& s, const char newStr) ｛delete sstr;int len ＝ strlen(newStr)；sstr ＝ new charlen ＋ 1;strcpy(sstr, newStr)；slength ＝ len;｝｀｀｀4、串的连接函数｀｀｀cppSeqString concatSeqString(const SeqString& s1, const SeqString& s2) ｛SeqString result;resultlength ＝ s1length ＋ s2length;resultstr ＝ new charresultlength ＋ 1;strcpy(resultstr, s1str)；strcat(resultstr, s2str)；return result;｝｀｀｀5、串的比较函数｀｀｀cppint compareSeqString(const SeqString& s1, const SeqString& s2) ｛return strcmp(s1str, s2str)；｝｀｀｀6、求子串函数｀｀｀cppSeqString subSeqString(const SeqString& s, int start, int len) ｛SeqString sub;sublength ＝ len;substr ＝ new charlen ＋ 1;strncpy(substr, sstr ＋ start, len)；substrlen ＝＇＼0'；return sub;｝｀｀｀7、串的插入函数｀｀｀cppvoid insertSeqString(SeqString& s, int pos, const SeqString& insertStr) ｛int newLength ＝ slength ＋ insertStrlength;char newStr ＝ new charnewLength ＋ 1;strncpy(newStr, sstr, pos)；strcpy(newStr ＋ pos, insertStrstr)；strcpy(newStr ＋ pos ＋ insertStrlength, sstr ＋ pos)；delete sstr;sstr ＝ newStr;slength ＝ newLength;｝｀｀｀8、串的删除函数｀｀｀cppvoid deleteSeqString(SeqString& s, int start, int len) ｛int newLength ＝ slength len;char newStr ＝ new charnewLength ＋ 1;strncpy(newStr, sstr, start)；strcpy(newStr ＋ start, sstr ＋ start ＋ len)；delete sstr;sstr ＝ newStr;slength ＝ newLength;｝｀｀｀（二）链式存储方式下串的实现1、定义一个节点结构体｀｀｀cppstruct LinkNode ｛char data;LinkNode next;LinkNode(char c) ： data(c)， next(NULL) ｛｝｝；｀｀｀2、定义一个链式存储的字符串类｀｀｀cppclass LinkString ｛private:LinkNode head;int length;public:LinkString(const char initStr)；～LinkString(）；void assign(const char newStr)；LinkString concat(const LinkString& other)；int compare(const LinkString& other)；LinkString subString(int start, int len)；void insert(int pos, const LinkString& insertStr)；void deleteSub(int start, int len)；｝；｀｀｀3、实现各个函数｀｀｀cppLinkString:：LinkString(const char initStr) ｛length ＝ strlen(initStr)；head ＝ NULL;LinkNode p ＝ NULL;for （int i ＝ 0; i ＜ length; i+＋）｛LinkNode newNode ＝ new LinkNode(initStri)；if （head ＝＝ NULL) ｛head ＝ newNode;p ＝ head;｝ else ｛p>next ＝ newNode;p ＝ p>next;｝｝｝LinkString:：～LinkString(）｛LinkNode p ＝ head;while （p) ｛LinkNode temp ＝ p;p ＝ p>next;delete temp;｝｝void LinkString:：assign(const char newStr) ｛／／先释放原有的链表LinkNode p ＝ head;while （p) ｛LinkNode temp ＝ p;p ＝ p>next;delete temp;｝length ＝ strlen(newStr)；head ＝ NULL;p ＝ NULL;for （int i ＝ 0; i ＜ length; i+＋）｛LinkNode newNode ＝ new LinkNode(newStri)；if （head ＝＝ NULL) ｛head ＝ newNode;p ＝ head;｝ else ｛p>next ＝ newNode;p ＝ p>next;｝｝｝LinkString LinkString:：concat(const LinkString& other) ｛LinkString result;LinkNode p1 ＝ head;LinkNode p2 ＝ otherhead;LinkNode p ＝ NULL;while （p1) ｛LinkNode newNode ＝ new LinkNode(p1-＞data)；if （resulthead ＝＝ NULL) ｛resulthead ＝ newNode;p ＝ resulthead;｝ else ｛p>next ＝ newNode;p ＝ p>next;｝p1 ＝ p1-＞next;｝while （p2) ｛LinkNode newNode ＝ new LinkNode(p2-＞data)；if （resulthead ＝＝ NULL) ｛resulthead ＝ newNode;p ＝ resulthead;｝ else ｛p>next ＝ newNode;p ＝ p>next;｝p2 ＝ p2-＞next;｝resultlength ＝ length ＋ otherlength;return result;｝int LinkString:：compare(const LinkString& other) ｛LinkNode p1 ＝ head;LinkNode p2 ＝ otherhead;while （p1 ＆＆ p2 ＆＆ p1-＞data ＝＝ p2-＞data) ｛p1 ＝ p1-＞next;p2 ＝ p2-＞next;｝if （p1 ＝＝ NULL ＆＆ p2 ＝＝ NULL) ｛return 0;｝ else if （p1 ＝＝ NULL) ｛return －1;｝ else if （p2 ＝＝ NULL) ｛return 1;｝ else ｛return p1-＞data p2-＞data;｝｝LinkString LinkString:：subString(int start, int len) ｛LinkString sub;LinkNode p ＝ head;for （int i ＝ 0; i ＜ start; i+＋）｛p ＝ p>next;｝for （int i ＝ 0; i ＜ len; i+＋）｛LinkNode newNode ＝ new LinkNode(p>data)；if （subhead ＝＝ NULL) ｛subhead ＝ newNode;｝ else ｛LinkNode temp ＝ subhead;while （temp>next) ｛temp ＝ temp>next;｝temp>next ＝ newNode;｝p ＝ p>next;｝sublength ＝ len;return sub;｝void LinkString:：insert(int pos, const LinkString& insertStr) ｛LinkNode p ＝ head;for （int i ＝ 0; i ＜ pos 1; i+＋）｛p ＝ p>next;｝LinkNode insertHead ＝ insertStrhead;while （insertHead) ｛LinkNode newNode ＝ new LinkNode(insertHead>data)；newNode>next ＝ p>next;p>next ＝ newNode;p ＝ p>next;insertHead ＝ insertHead>next;｝length ＋＝ insertStrlength;｝void LinkString:：deleteSub(int start, int len) ｛LinkNode p ＝ head;for （int i ＝ 0; i ＜ start 1; i+＋）｛p ＝ p>next;｝LinkNode temp ＝ p>next;for （int i ＝ 0; i ＜ len; i+＋）｛LinkNode delNode ＝ temp;temp ＝ temp>next;delete delNode;｝p>next ＝ temp;length ＝ len;｝｀｀｀（三）测试用例1、顺序存储方式的测试｀｀｀cppint main(）｛SeqString s1 ＝ createSeqString(＂Hello"）；SeqString s2 ＝ createSeqString(＂World"）；SeqString s3 ＝ concatSeqString(s1, s2)；std:：cout ＜＜＂连接后的字符串: ＂＜＜ s3str ＜＜ std:：endl; int cmpResult ＝ compareSeqString(s1, s2)；if （cmpResult ＜ 0) ｛std:：cout ＜＜＂s1 小于 s2" ＜＜ std:：endl;｝ else if （cmpResult ＝＝ 0) ｛std:：cout ＜＜＂s1 等于 s2" ＜＜ std:：endl;｝ else ｛std:：cout ＜＜＂s1 大于 s2" ＜＜ std:：endl;｝SeqString sub ＝ subSeqString(s1, 1, 3)；std:：cout ＜＜＂子串: ＂＜＜ substr ＜＜ std:：endl; insertSeqString(s1, 2, s2)；std:：cout ＜＜＂插入后的字符串: ＂＜＜ s1str ＜＜ std:：endl; deleteSeqString(s1, 3, 2)；std:：cout ＜＜＂删除后的字符串: ＂＜＜ s1str ＜＜ std:：endl; return 0;｝｀｀｀2、链式存储方式的测试｀｀｀cppint main(）｛LinkString ls1(＂Hello"）；LinkString ls2(＂World"）；LinkString ls3 ＝ ls1concat(ls2)；std:：cout ＜＜＂连接后的字符串: ＂；LinkNode p ＝ ls3head;while （p) ｛std:：cout ＜＜ p>data;p ＝ p>next;｝std:：cout ＜＜ std:：endl;int cmpResult ＝ ls1compare(ls2)；if （cmpResult ＜ 0) ｛std:：cout ＜＜＂ls1 小于 ls2" ＜＜ std:：endl;｝ else if （cmpResult ＝＝ 0) ｛std:：cout ＜＜＂ls1 等于 ls2" ＜＜ std:：endl;｝ else ｛std:：cout ＜＜＂ls1 大于 ls2" ＜＜ std:：endl;｝LinkString sub ＝ ls1subString(1, 3)；std:：cout ＜＜＂子串: ＂；p ＝ subhead;while （p) ｛std:：cout ＜＜ p>data;p ＝ p>next;｝std:：cout ＜＜ std:：endl;ls1insert(2, ls2)；std:：cout ＜＜＂插入后的字符串: ＂；p ＝ ls1head;while （p) ｛std:：cout ＜＜ p>data;p ＝ p>next;｝std:：cout ＜＜ std:：endl;ls1deleteSub(3, 2)；std:：cout ＜＜＂删除后的字符串: ＂；p ＝ ls1head;while （p) ｛std:：cout ＜＜ p>data;p ＝ p>next;｝std:：cout ＜＜ std:：endl;return 0;｝｀｀｀五、实验结果及分析（一）顺序存储方式1、连接操作成功实现，输出了正确连接后的字符串。
数据结构串实验报告
数据结构串实验报告实验报告课程数据结构实验名称实验三串学号姓名实验日期:实验三串实验目的: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算法的少。
数据结构串的实验报告
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++进行编写，而且难度要比我预期的要低，效果反而更好了。
同时，串基于字符数组实现要容易得多，而且对于一维数组的具体操作，已经相对较为熟练，而且也提供了很多关于字符串的相关函数，所以为了提高编程水平，这次对于串的操作，都不依赖系统函数和字符串函数，相反，深入初始化，插入，删除，遍历等功能的本质，对字符串的底层进行编程实现。