数据结构实验报告3--链串

合集下载

数据结构实验实训报告范文

数据结构实验实训报告范文

一、实验目的1. 理解并掌握数据结构的基本概念和常用算法。

2. 学会使用C语言实现线性表、栈、队列、树和图等基本数据结构。

3. 培养动手实践能力,提高编程水平。

二、实验内容1. 线性表(1)顺序表(2)链表2. 栈(1)顺序栈(2)链栈3. 队列(1)顺序队列(2)链队列4. 树(1)二叉树(2)二叉搜索树5. 图(1)邻接矩阵表示法(2)邻接表表示法三、实验环境1. 操作系统:Windows 102. 编程语言:C语言3. 编译器:Visual Studio 20194. 实验软件:C语言开发环境四、实验步骤1. 线性表(1)顺序表1)定义顺序表结构体2)实现顺序表的初始化、插入、删除、查找等基本操作3)编写测试程序,验证顺序表的基本操作(2)链表1)定义链表结构体2)实现链表的创建、插入、删除、查找等基本操作3)编写测试程序,验证链表的基本操作2. 栈(1)顺序栈1)定义顺序栈结构体2)实现顺序栈的初始化、入栈、出栈、判空等基本操作3)编写测试程序,验证顺序栈的基本操作(2)链栈1)定义链栈结构体2)实现链栈的初始化、入栈、出栈、判空等基本操作3)编写测试程序,验证链栈的基本操作3. 队列(1)顺序队列1)定义顺序队列结构体2)实现顺序队列的初始化、入队、出队、判空等基本操作3)编写测试程序,验证顺序队列的基本操作(2)链队列1)定义链队列结构体2)实现链队列的初始化、入队、出队、判空等基本操作3)编写测试程序,验证链队列的基本操作4. 树(1)二叉树1)定义二叉树结构体2)实现二叉树的创建、遍历、查找等基本操作3)编写测试程序,验证二叉树的基本操作(2)二叉搜索树1)定义二叉搜索树结构体2)实现二叉搜索树的创建、遍历、查找等基本操作3)编写测试程序,验证二叉搜索树的基本操作5. 图(1)邻接矩阵表示法1)定义邻接矩阵结构体2)实现图的创建、添加边、删除边、遍历等基本操作3)编写测试程序,验证邻接矩阵表示法的基本操作(2)邻接表表示法1)定义邻接表结构体2)实现图的创建、添加边、删除边、遍历等基本操作3)编写测试程序,验证邻接表表示法的基本操作五、实验结果与分析1. 线性表(1)顺序表实验结果表明,顺序表的基本操作实现正确,测试程序运行稳定。

数据结构 串 实验报告

数据结构 串 实验报告

实验报告实验名称:串实验目的:(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)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。

通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。

实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。

通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。

通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。

同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。

在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。

通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。

总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。

在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。

C语言数据结构----链栈实验报告

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);}。

数据结构串的实验总结

数据结构串的实验总结

数据结构串的实验总结《数据结构串的实验总结》整体感受嘛,这数据结构中的串实验就像一场充满挑战与惊喜的旅程。

开始的时候,真觉得有些头疼,就像面对一个错综复杂的迷宫,完全不知道从哪儿入手。

具体收获可真是不少。

首先,我对串的基本概念有了透彻的理解,什么是串,串的长度、空串、空格串等等。

在实现串的操作时,比如串的连接、匹配之类的,那可真是让我费了不少心思。

比如说在实现串的模式匹配算法中的BF算法时,我才清楚需要挨个比较字符,就像在人群中逐个查找一个特定的人一样辛苦但又很有成就感。

还有KMP算法,这个算法刚开始理解简直难上天了,它那复杂的部分匹配值计算和next数组的构建,但是一旦理解了它的精髓,就感觉像发现了一个快捷通道。

原来KMP 算法就是利用已经比较过的信息,避免不必要的比较,就像你走过一遍迷宫,记住了哪些路是死胡同,下次走的时候就可以避开了。

重要发现也得记一笔。

在做串的存储结构实验的时候,我发现顺序存储结构在某些情况下很方便,比如串的长度固定或者不需要频繁插入删除的时候。

而链式存储结构则在灵活处理串的变化方面更有优势,这就像是住在公寓和房车的区别,一个固定但是稳定,一个虽然变动大但是更灵活,可以随时根据需求调整内部布局。

反思一下,自己在做实验的过程中太过于关注实现结果而忽略了算法的时间复杂度和空间复杂度优化。

比如在BF算法中,如果字符串很长,那简单的逐个比较效率是非常低的,当时怎么就没有多想想怎么优化呢,真是太不应该了。

现在想想,如果当时能从一开始就着重关注效率方面的问题,后面可能就不需要花这么多时间返工了。

从这个串的实验中得到的启示就是做事情之前一定要考虑全面。

遇到难题的时候不要害怕,像理解KMP算法一样,多花时间多思考,总能找到解决方案的。

而且在解决问题的过程中,要不断思考有没有更好更高效的方法,不能仅仅满足于把功能实现了就好。

要从各个方面去考量,就像看待一个人的综合素质一样,不仅要看他能不能完成任务,还要看他完成任务的质量和效率。

串-数据结构实验报告

串-数据结构实验报告

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

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

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

数据结构串实验报告

数据结构串实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构链表实验报告

数据结构链表实验报告

实验报告填写说明(实验项目名称、实验项目类型必须与实验教学大纲保持一致)1.实验环境:实验用的软、硬件环境。

2.实验目的:根据实验教学大纲,写出实验的要求和目的。

3.实验原理:简要说明本实验项目所涉及的理论知识。

4.实验方案:这是实验报告极其重要的容。

对于验证性验,要写清楚操作方法,需要经过哪几个步骤来实现其操作。

对于设计性和综合性实验,还应写出设计思路和设计方法。

对于创新性实验,还应注明其创新点。

5.实验过程:写明执行实验方案的实验过程。

6.实验结论:根据实验过程中得到的结果,做出结论。

7.实验小结:本次实验的体会和建议。

8.指导教师评语及成绩:指导教师依据学生的实际报告内容,给出本次实验报告的评价和成绩。

1 实验环境:VC++6.02 实验目的 :掌握单链表的基本操作在链式存储结构上的实现。

3实验原理:(1)#define MAXSIZE 5 //链表的最大长度typedef struct{ElemType data;int cur;}component,SLinkList[MAXSIZE];(2)动态分配的物理结构,每个结点值域指向其直接后继结点,指针为数据元素之间逻辑关系的映象。

4实验方案:根据链表的结构编写主函数,调用链表的构造空表算法,查找算法,插入算法以及删除算法,验证算法的正确性。

5实验过程:(1).编写算法以及主函数(2).编译运行出错,查找错误(3).改正错误,重新编译运行,没有错误(4).输入测试数据,验证结果,得出结论(5).保存结果,写入实验报告中6实验结论附录1:源程序。

数据结构——串实践报告

数据结构——串实践报告

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

串的数据结构实验报告

串的数据结构实验报告

串的数据结构实验报告串的数据结构实验报告一、引言在计算机科学中,串(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算法的编写和调试,但在老师和同学的指导下,我成功地解决了这些问题。

数据结构实验报告《三、串及其应用》

数据结构实验报告《三、串及其应用》

数据结构实验报告《三、串及其应用》时间: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语句进行选择判断,并用类的对象调用类的成员函数以实现特定的功能。

【精品】数据结构串实验报告

【精品】数据结构串实验报告

【精品】数据结构串实验报告
(仅校内可用)
本次实验是基于数据结构串的相关知识,设计、实现及实验关于串的操作,并要求我们编写综合性实验报告。

1、实验目的是了解串结构及其实现方法,并能够用有限的时间内完成实验。

2、实验要求:
(1)实现关于串的一组基本操作
(2)实现串的模式匹配算法
3、实验的进度:
(1)完成程序的设计,要求建立合理的数据结构,编写部分重要算法,调试程序;
(2)设计一组完整的数据,并完成所设计程序的测试;
(3)对串模式匹配算法和高效率算法的效率、正确性进行测试;
(4)完成实验总结,参加试验验收。

4、实验结果:
(1)建立了串的节点数据结构,并编写相关操作算法,经测试结果显示,程序的实现能做到正确、有效的运行;
(2)完成对串模式匹配算法和高效率算法的测试,匹配算法水平介于暴力及KMP算法之间,效率较高;高效率算法在重复部分采用滑动窗口技术,同时避免了重复移动结点带来的时间开销,效率较高且正确性得到了优化;
(3)完成了实验总结,并得出本次实验的结论:实现串的模式匹配算法和高效率算法能够较好地实现串的基本操作,同时具有较高的效率;
最后,在实验过程中,我收获颇丰,加深了对串结构及实现方法的理解,使我对数据结构有了更全面的认识。

数据结构实验报告三线性表的链式存储

数据结构实验报告三线性表的链式存储

实验报告三线性表的链式存储班级: 2010XXX 姓名: HoogLe 学号: 2010XXXX 专业: XXXX*****************(1)实验目的:(2)掌握单链表的基本操作的实现方法。

(3)掌握循环单链表的基本操作实现。

(4)掌握两有序链表的归并操作算法。

实验内容: (请采用模板类及模板函数实现)1.线性表链式存储结构及基本操作算法实现[实现提示] (同时可参见教材p64-p73页的ADT描述及算法实现及ppt)函数、类名称等可自定义, 部分变量请加上学号后3位。

也可自行对类中所定义的操作进行扩展。

所加载的库函数或常量定义:#include <iostream>using namespace std;(1)单链表存储结构类的定义:template<class T>class LinkList{public:LinkList(); //初始化带头结点空单链表构造函数实现LinkList(T a[],int n);//利用数组初始化带头结点的单链表构造函数实现~LinkList();int length(); //求单链表表长算法T get(int i); //获得单链表中第i个结点的值算法int locate(T temp);void insert(int i,T temp); //在带头结点单链表的第i个位置前插入元素e算法T Delete(int i); //在带头结点单链表中删除第i个元素算法void print(); //遍历单链表元素算法bool isEmpty(); //判单链表表空算法void deleleAll(); //删除链表中所有结点算法(这里不是析构函数, 但功能相同)private:Node<T> *head;};(2)初始化带头结点空单链表构造函数实现输入:无前置条件: 无动作: 初始化一个带头结点的空链表输出:无后置条件: 头指针指向头结点。

数据结构串实验报告

数据结构串实验报告

数据结构串实验报告实验报告课程数据结构实验名称实验三串学号姓名实验日期:实验三串实验目的: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++进行编写,而且难度要比我预期的要低,效果反而更好了。

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

数据结构实验报告串

数据结构实验报告串

数据结构实验报告串《数据结构实验报告串》在数据结构课程中,实验报告是非常重要的一环。

通过实验报告,我们能够将课堂上学到的知识应用到实际中,加深对数据结构的理解和掌握。

本次实验报告串将介绍我们在数据结构实验中所进行的一系列实验,以及实验结果和分析。

实验一:数组和链表的比较在第一个实验中,我们对数组和链表进行了比较。

我们通过编写代码,分别实现了数组和链表的基本操作,包括插入、删除、查找等。

通过对比实验结果,我们发现在插入和删除操作中,链表的效率明显高于数组,而在查找操作中,数组的效率更高。

这说明在不同的场景下,数组和链表都有各自的优势和劣势。

实验二:栈和队列的应用在第二个实验中,我们学习了栈和队列的应用。

我们通过编写代码,实现了栈和队列的基本操作,并应用到实际问题中。

我们发现栈适合用于实现逆波兰表达式和括号匹配等问题,而队列适合用于实现广度优先搜索和模拟排队等问题。

这些实际应用让我们更加深入地理解了栈和队列的特点和用途。

实验三:树和图的遍历在第三个实验中,我们学习了树和图的遍历算法。

我们通过编写代码,实现了深度优先搜索和广度优先搜索算法,并应用到树和图的遍历中。

我们发现深度优先搜索适合用于解决迷宫问题和拓扑排序等问题,而广度优先搜索适合用于解决最短路径和连通性问题。

这些实验让我们更加深入地理解了树和图的遍历算法,以及它们在实际中的应用。

通过以上一系列实验,我们对数据结构的理论知识有了更深入的理解,同时也掌握了一些实际应用的技能。

实验报告串的编写过程也让我们更加熟练地掌握了数据结构的相关操作和算法。

希望通过这些实验,我们能够更好地应用数据结构知识,解决实际中的问题,提高编程能力和算法水平。

数据结构实验报告串

数据结构实验报告串

数据结构实验报告串数据结构实验报告串一、引言数据结构是计算机科学的基础,它研究数据的组织、存储和管理方式。

在本次实验中,我们将学习和实践一些常见的数据结构,如链表、栈和队列。

通过实验,我们将深入了解这些数据结构的特点、优势和应用场景。

二、链表链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表可以分为单向链表和双向链表两种类型。

在实验中,我们实现了一个简单的单向链表,并进行了一系列操作,如插入、删除和遍历。

通过实验,我们发现链表的插入和删除操作时间复杂度为O(1),这是因为链表的节点可以通过指针直接连接,而不需要移动其他节点。

然而,链表的缺点是访问节点的时间复杂度为O(n),因为我们需要从头节点开始遍历链表直到找到目标节点。

三、栈栈是一种后进先出(LIFO)的数据结构,它只允许在栈顶进行插入和删除操作。

在实验中,我们实现了一个简单的栈,并进行了一系列操作,如入栈、出栈和获取栈顶元素。

通过实验,我们发现栈的插入和删除操作时间复杂度为O(1),这是因为栈的元素只能在栈顶进行操作。

栈的应用场景很广泛,例如函数调用和表达式求值。

在函数调用中,每次函数调用时,会将函数的返回地址和局部变量等信息存储在栈中,以便函数执行完毕后可以返回到正确的位置。

四、队列队列是一种先进先出(FIFO)的数据结构,它允许在队尾插入元素,在队头删除元素。

在实验中,我们实现了一个简单的队列,并进行了一系列操作,如入队、出队和获取队头元素。

通过实验,我们发现队列的插入和删除操作时间复杂度为O(1),这是因为队列的元素只能在队头和队尾进行操作。

队列的应用场景很多,例如任务调度和消息传递。

在任务调度中,每个任务都会被加入到队列中,然后按照先后顺序执行,确保任务按照正确的顺序完成。

五、实验总结通过本次实验,我们深入了解了链表、栈和队列这些常见的数据结构。

我们学习了它们的特点、优势和应用场景,并通过实践掌握了它们的基本操作。

串的数据结构实验报告

串的数据结构实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
宁波工程学院电信学院计算机教研室
实验报告
课程名称:___ 数据结构 ___ __
实验项目: 链串的基本算法
指导教师:
实验位置: 电子楼二楼机房
姓 名:
学 号:
班 级: 计科102
日期:2011/10/13
一、实验目的
1)熟悉串的定义和串的基本操作。
2)掌握链串的基本运算。
3)加深对串数据结构的理解,逐步培养解决实际问题的编程能力。
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){
printf("\n");
}
//判断字符串是否为空
void empstr(listring *s){
if(s->next==NULL)
printf("字符串是空的!");
else
printf("字符串不为空!");
}
void initstr(listring *&s){
s=(listring *)malloc(sizeof(listring));
}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));
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;
}
//字符串删除
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){
(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)
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));
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))
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);
二、实验环境
装有Visual C++6.0的计算机。
三、实验内容
编写一个程序,实现链串的各种基本运算,并在此基础上设计一个主程序。具体如下:
编写栈的基本操作函数
链串类型定义如下所示:
typedef struct snode{
char data;
struct snode *next;
}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;
printf("输出s4:\n");
dispstr(s4);
s5=suபைடு நூலகம்str(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相等!");
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;
}
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)建立串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
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;
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;
s->next=NULL;
}
//主函数
int main(void){
listring *s,*s1,*t,*t1,*s2,*s3,*s4,*s5,*s6;
int l;
strassign(s,"abcdefghijklmn");
相关文档
最新文档