数据结构实验报告3链串

合集下载

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

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

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

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

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

数据结构串实验报告

数据结构串实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构顺序串和链串实验报告

数据结构顺序串和链串实验报告

《数据结构》课程实验报告实验名称顺序串和链串实验序号 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. 熟练运用串的常用算法,如串的模式匹配算法(如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算法的编写和调试,但在老师和同学的指导下,我成功地解决了这些问题。

数据结构 实验报告

数据结构 实验报告

数据结构实验报告数据结构实验报告背景介绍:数据结构是计算机科学中的重要概念,它涉及到如何组织和存储数据,以及如何在数据中进行操作和检索。

在本次实验中,我们将学习并实践几种常见的数据结构,包括数组、链表、栈和队列。

实验目的:通过本次实验,我们的目标是深入了解数据结构的基本概念和操作,并通过编写代码来实现和应用这些数据结构。

通过实践,我们将能够更好地理解数据结构在实际问题中的应用和效果。

实验过程:1. 数组:数组是一种线性数据结构,它由一系列相同类型的元素组成,这些元素在内存中是连续存储的。

我们首先学习了如何创建和初始化数组,并实现了一些常见的数组操作,如插入、删除和查找元素。

通过编写代码,我们能够更好地理解数组的特点和使用方法。

2. 链表:链表是另一种常见的线性数据结构,与数组不同,链表中的元素在内存中并不连续存储,而是通过指针相互连接。

我们学习了单向链表和双向链表的实现,并实现了插入、删除和查找元素的操作。

链表的灵活性使其在某些情况下比数组更加适用。

3. 栈:栈是一种后进先出(LIFO)的数据结构,类似于弹夹中的子弹。

我们学习了如何使用数组和链表来实现栈,并实现了入栈和出栈的操作。

栈在计算机科学中有广泛的应用,例如函数调用、表达式求值等。

4. 队列:队列是一种先进先出(FIFO)的数据结构,类似于排队等候的人群。

我们学习了如何使用数组和链表来实现队列,并实现了入队和出队的操作。

队列在操作系统、网络通信等领域中有着重要的应用。

实验结果与讨论:通过本次实验,我们成功地实现了数组、链表、栈和队列这几种常见的数据结构,并能够熟练地进行插入、删除和查找等操作。

我们还通过编写一些实际问题的代码,验证了这些数据结构在解决实际问题中的有效性和效率。

结论:数据结构是计算机科学中的重要基础概念,通过本次实验,我们深入了解了几种常见的数据结构,并通过编写代码实现了这些数据结构的基本操作。

这将为我们今后在算法设计和程序开发中提供坚实的基础,并帮助我们更好地理解和解决实际问题。

数据结构实验报告三

数据结构实验报告三
5.运行和测试
<1>初始化一个队列。
循环队列:
链队列:
<2>判断是否队空。
循环队列:
链队列:
<3>判断是否队满。
循环队列:
第一组数据:入队n个元素,判断队满
第二组数据:用循环方式将1到99,99个元素入队,判队满
入队
第一组数据:4,7,8,12,20,50
第二组数据:a,b,c,d,f,g
出队
取队头元素
3.数据结构设计
循环队列
4.算法设计
(除书上给出的基本运算(这部分不必给出设计思想),其它实验内容要给出算法设计思想)
求当前队列中的元素个数:书写函数配合出队函数和判对空函数,定义一个整型变量i计数,在一个循环中每出对一次,计数器加一,直到对空,返回i即为队列元素个数。
第二题:首先判断队列是否队满,如果队满打印队满,结束程序,如果队列不满则进行下一步操作,定义一个变量x,从键盘输入其值,判断如果x的值为0,结束程序,如果不为0进入循环,如果x的模运算不等于0,将x入队,反之出队,直到x的模运算等于0,最后通过循环输出队列。
实现:从列不空,删除Q的队头元素用e返回其值,并返回OK,则返回ERROR
Status EnQueue (LinkQueue *Q, QE1emType e) {
QueuePtr p
if (Q->front==Q- >rear)
三、循环队列与链队列性能分析
1.循环队列与链队列基本操作时间复杂度均为0(1);
2.队列的抽象数据队列Data同线性表。元素具有相同的类型,相邻元素具有前驱和后继关系。Operation InitQueue(*Q):初始化操作,建立一个空队列Q. DestoryQueue(*Q):若队列Q存在,则销毁它。ClearQueue(*Q):将队列Q清空 GetHead(Q,*e):若队列Q存在且非空,用e返回队列Q的队头元素。EnQueue(*Q,e):若队列Q存在且非空, 插入新元素e到队列Q中并称为队元素。DeQueue(*Q,*e):删除队列Q中队头元素,并用e返回其值QueueL ength(Q)。

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

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

实验报告三线性表的链式存储班级: 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. 栈的实现与应用栈是一种后进先出(LIFO)的数据结构,我们将学习如何使用数组和链表两种方式来实现栈,并通过实例来演示栈的应用场景,如括号匹配、表达式求值等。

2. 队列的实现与应用队列是一种先进先出(FIFO)的数据结构,我们将学习如何使用数组和链表两种方式来实现队列,并通过实例来演示队列的应用场景,如任务调度、消息传递等。

3. 链表的实现与应用链表是一种动态数据结构,相比数组具有更好的灵活性和扩展性。

我们将学习如何使用指针来实现链表,并通过实例来演示链表的应用场景,如链表的插入、删除、反转等操作。

4. 二叉树的实现与应用二叉树是一种常见的树形结构,我们将学习如何使用指针来实现二叉树,并通过实例来演示二叉树的应用场景,如二叉树的遍历、搜索等操作。

三、实验过程1. 栈的实现与应用我们首先使用数组来实现栈,并编写相关的入栈、出栈、判空、获取栈顶元素等操作。

然后,我们通过括号匹配和表达式求值两个实例来验证栈的正确性和应用性。

2. 队列的实现与应用我们使用数组来实现队列,并编写相关的入队、出队、判空、获取队头元素等操作。

然后,我们通过任务调度和消息传递两个实例来验证队列的正确性和应用性。

3. 链表的实现与应用我们使用指针来实现链表,并编写相关的插入、删除、反转等操作。

然后,我们通过链表的插入和删除操作来验证链表的正确性和应用性。

实验三 串基本操作的编程实现

实验三 串基本操作的编程实现

HUBEI UNIVERSITY OF AUTOMOTIVE TECHNOLOGY Array
数据结构
实验三串基本操作的编程实现
【实验目的】
内容:串基本操作的编程实现
要求:
串基本操作的编程实现(2学时,验证型),掌握串的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、合并、剪裁等操作,存储结构可以在顺序结构或链接结构、索引结构中任选,也可以全部实现。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】
验证性实验(学时数:2H)
【实验内容】
字符串长度计算,字符串的连接,字符串的替换,求子串等。

【注意事项】
1.开发语言:使用C。

2.可以自己增加其他功能。

【实验分析、说明过程】
【思考问题】
【实验小结】 (总结本次实验的重难点及心得、体会、收获)。

相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

宁波工程学院电信学院计算机教研室实验报告一、实验目的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; 后运行正确。

相关文档
最新文档