数据结构_实验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、扩充编辑操作,如对某行进行串替换?。
实验三串基本操作的编程实现
实验三串基本操作的编程实现引言:串是由零个或多个字符组成的有限序列,是一种非常基础也非常重要的数据结构。
在本实验中,我们将学习串的基本操作,并使用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.2.撰写实验报告的目的二、内容1.说明实验次数及实验内容本次实验用一个实验课时完成。
实验内容:1. 编写函数StrAssign(), StrCopy() , StrLenth() , StrCompare() , StrConcat() ,Substring(), Replace(),完成串赋值,串复制,求串长度,串比较,串连接,求字串,子串替代等相应功能。
注:Replace() 依赖Find_KMP()2. 使用KMP 算法,编写函数Find_KMP(char *S,char *P,int start)实现字符串匹配。
测试数据:2.1char S[] = “abcabcabcd”;char P[] = “abcabcd”;2.2char S[] = “abcdababcabcdabcabcabcd”;char P[] = “abcabcd”;2.3char S[] = “cocaocoaoc”;char P[] = “coaoc”;要求: 1.打印出模式串P 的next[]模式数组;2.完成Find_KMP()后在Repalce()中调用,将P 替换成“AAA”。
注意2.2 有2 个地方要替换。
3. 创建三元组实现以下稀疏矩阵的存储,并利用三元组实现稀疏矩阵的转置,比较“按需查找”方法与“按位就座”方法的区别。
0 12 9 0 0 0 00 0 0 0 0 0 03 0 0 0 0 14 00 0 24 0 0 0 00 18 0 0 0 0 015 0 0 7 0 0 0建议实现流程为1.矩阵2.三元组3.转置的三元组4.转置的矩阵,将3 或4打印出来。
2.做实验完成情况实验内容在实验课时时间内完成(提前编写了大概1/2部分的代码),选做内容也完成。
本次实验内容较多,为使代码看着简洁有条理,采用了建工程的方式。
串部分:自定义了头文件String.h:/*自定义头文件*/#include<stdio.h>#define MAX_LEN 255typedef unsigned char SString[MAX_LEN + 1];/*自定义函数*/void StrAssign(SString &T, char s[]);//将字符串常量s赋给Tvoid StrPrint(SString T);//打印串void StrCopy(SString &T, SString S);//串复制void test();//检验串操作int StrLength(SString T);//求串长int StrCompare(SString T, SString S);//比较串,T>S返回正值,T<S返回负值,相等返回0void StrConcat(SString &T, SString S1, SString S2);//用T返回SString 类型串S1、S2连接成的新串void SubString(SString &S, SString T, int pos, int len);//用S返回串T中起始位置为pos,长度为len的字串void Index(SString S, SString T, int pos[]);//若S串中存在不重叠的子串T,则用pos[]返回所有T串的起始位置void StrReplace(SString &S, SString T, SString V);//若串S中存在字串T,则用V替代所有不重叠的Tvoid StrInsert(SString &S, int pos, SString T);//在串S中pos位置插入子串Tvoid StrDelete(SString &S, int pos, int len);//在串S中pos位置删除长度为len的子串void GetNext(SString S, int next[]);//求模式串中的next函数修正值并写入数组next[]int FindKMP(SString S, SString T, int start);//在串S中从start位置开始,查找第一次出现模式T的位置返回,没找到返回-1void StrReplace2(SString &S, SString T, SString V);//若串S中存在字串T,则用V替代所有不重叠的Tvoid KMP();//KMP算法及其应用在头文件中对所有要用到的自定义函数进行了声明,各函数的功能可见代码注释部分。
数据结构实验报告串
数据结构实验报告串《数据结构实验报告串》在数据结构课程中,实验报告是非常重要的一环。
通过实验报告,我们能够将课堂上学到的知识应用到实际中,加深对数据结构的理解和掌握。
本次实验报告串将介绍我们在数据结构实验中所进行的一系列实验,以及实验结果和分析。
实验一:数组和链表的比较在第一个实验中,我们对数组和链表进行了比较。
我们通过编写代码,分别实现了数组和链表的基本操作,包括插入、删除、查找等。
通过对比实验结果,我们发现在插入和删除操作中,链表的效率明显高于数组,而在查找操作中,数组的效率更高。
这说明在不同的场景下,数组和链表都有各自的优势和劣势。
实验二:栈和队列的应用在第二个实验中,我们学习了栈和队列的应用。
我们通过编写代码,实现了栈和队列的基本操作,并应用到实际问题中。
我们发现栈适合用于实现逆波兰表达式和括号匹配等问题,而队列适合用于实现广度优先搜索和模拟排队等问题。
这些实际应用让我们更加深入地理解了栈和队列的特点和用途。
实验三:树和图的遍历在第三个实验中,我们学习了树和图的遍历算法。
我们通过编写代码,实现了深度优先搜索和广度优先搜索算法,并应用到树和图的遍历中。
我们发现深度优先搜索适合用于解决迷宫问题和拓扑排序等问题,而广度优先搜索适合用于解决最短路径和连通性问题。
这些实验让我们更加深入地理解了树和图的遍历算法,以及它们在实际中的应用。
通过以上一系列实验,我们对数据结构的理论知识有了更深入的理解,同时也掌握了一些实际应用的技能。
实验报告串的编写过程也让我们更加熟练地掌握了数据结构的相关操作和算法。
希望通过这些实验,我们能够更好地应用数据结构知识,解决实际中的问题,提高编程能力和算法水平。
数据结构(C语言版)_第3章 串与数组
char data; struct lnode *next;
}lstring;
3.3.3 串的存储结构——链式存储结构
当结点大小>1时,可以采用块链结构。
#define CHUNKSIZE 100
/*可由用户定义块的大小*/
typedef struct Chunk
第三章 串与数组
本章要点
➢字符串的基本概念与基本运算 ➢字符串的存储和基本运算的实现 ➢数组的概念和基本运算 ➢数组的存储结构 ➢特殊矩阵的压缩存储及运算 ➢广义表的概念及相关术语 ➢广义表的存储形式
3.1 “文学研究助手”案例导入
“文学研究助手”引例:请从下面的英文文章里,统计其中 good出现的次数和位置,并查找单词the所在的行号,该行中出 现的次数以及在该行中的相应位置。
3.4.1 数组的定义
数组是n个具有相同类型的数据元素构成的有限序列,数组 中的数据是按顺序存储在一块地址连续的存储单元中。
数组中的每一个数据通常称为数组元素,数组元素用下标 区分,其中下标的个数由数组的维数决定。
若线性表中的数据元素为非结构的简单元素,则称为一维 数组,又称为向量;若一维数组中的数据元素又是一维数组结 构,则称为二维数组;依次类推,若二维数组中的元素又是一 个一维数组结构,则称作三维数组。
3.3.4 串的基本操作的实现算法
第二种顺序存储方式下几种基本操作的算法
算法1:串连接操作 算法2:串比较操作 算法3:取子串操作 算法4:串插入操作 算法5:串删除操作 算法6:串置换函数 算法7:子串定位操作
3.3.5 串的应用
【例3-1】设计一个算法求串s中出现的第1个最长重复子串 及其位置。
数据结构实验三实验报告
数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。
具体来说,我们需要实现一个树的数据结构,并对其进行插入、删除、查找等操作,同时还需要实现树的遍历算法,包括先序、中序和后序遍历。
二、实验原理树是一种非线性的数据结构,由结点和边组成。
树的每个结点都可以有多个子结点,但是每个结点只有一个父结点,除了根结点外。
树的基本操作包括插入、删除和查找。
在本次实验中,我们采用二叉树作为实现树的数据结构。
二叉树是一种特殊的树,每个结点最多只有两个子结点。
根据二叉树的特点,我们可以使用递归的方式实现树的插入、删除和查找操作。
三、实验过程1. 实现树的数据结构首先,我们需要定义树的结点类,包括结点值、左子结点和右子结点。
然后,我们可以定义树的类,包括根结点和相应的操作方法,如插入、删除和查找。
2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。
我们可以通过递归的方式实现插入操作。
具体来说,如果要插入的值小于当前结点的值,则将其插入到左子树中;如果要插入的值大于当前结点的值,则将其插入到右子树中。
如果当前结点为空,则将新的结点作为当前结点。
3. 实现删除操作删除操作是将指定的结点从树中移除的过程。
我们同样可以通过递归的方式实现删除操作。
具体来说,如果要删除的值小于当前结点的值,则在左子树中继续查找;如果要删除的值大于当前结点的值,则在右子树中继续查找。
如果要删除的值等于当前结点的值,则有三种情况:- 当前结点没有子结点:直接将当前结点置为空。
- 当前结点只有一个子结点:将当前结点的子结点替代当前结点。
- 当前结点有两个子结点:找到当前结点右子树中的最小值,将其替代当前结点,并在右子树中删除该最小值。
4. 实现查找操作查找操作是在树中寻找指定值的过程。
同样可以通过递归的方式实现查找操作。
具体来说,如果要查找的值小于当前结点的值,则在左子树中继续查找;如果要查找的值大于当前结点的值,则在右子树中继续查找。
数据结构与管理串和数组实验报告
《数据结构与数据管理》实验报告学生姓名:徐桂平0813011022 实验日期:2009-12-16实验一实验名称串与数组实验目的1、掌握串的有关运算;2、掌握矩阵的顺序存储形式;实验题目1、利用串的顺序定长存储结构实现两个子串的连接。
•要求:两个子串从键盘输入获得;从屏幕显示连接后的新串元素列表。
2 、利用串的堆分配存储结构实现两个子串的连接。
•要求:两个子串从键盘输入获得;从屏幕显示连接后的新串元素列表。
3 、将已知的稀疏矩阵进行转置运算。
•要求:从键盘输入矩阵的元素,用三元组表进行存储,显示稀疏矩阵的元素;调用稀疏矩阵(三元组存储结构)转置算法,显示转置后的稀疏矩阵的元素。
源程序代码:1、#include<stdio.h>#include"string.h"#define MAXSTRLEN 255typedef char SString[MAXSTRLEN+1];SString L,S;void main(){ int i,m,n;printf("输入第一个串:"); gets(L);printf("输入第二个串:"); gets(S);m=strlen(L); n=strlen(S);for(i=0;i<=n;i++)L[i+m]=S[i] ; printf("%s",L); printf("\n"); }2、#include<stdio.h>#include"malloc.h"#include"string.h"#define MAXSTRLEN 255typedef char SString[MAXSTRLEN];typedef struct{ char *ch; int length;}HString;SString L,S; HString R,T;void main(){ int i;printf("输入第一个串:"); gets(L);printf("输入第二个串:"); gets(S);R.length=strlen(L); T.length=strlen(S);R.ch=(char *)malloc((R.length)*sizeof(char)); strcpy(R.ch,L); T.ch=(char *)malloc((T.length)*sizeof(char)); strcpy(T.ch,S); //重新分配空间R.ch=(char*)realloc(R.ch,(R.length+R.length+1)*sizeof(char));//连接for(i=0;i<=T.length;i++)R.ch[R.length+i]=T.ch[i];printf("连接后为:\n%s",R.ch); printf("\n"); }3、#include<stdio.h>#define MAXSIZE 12500typedef int ElemType;typedef struct{ int a,b; //a是行序号,b是列序号ElemType e; }Triple;typedef struct{ Triple date[MAXSIZE+1];int mu,nu,tu; }TSMatrix;void main(){ int i,j,col; int p=1,q=1;TSMatrix M,T; printf("输入M矩阵的行和列:");scanf("%d,%d",&M.mu,&M.nu);printf("输入三元组,(以0结束每输入一个三元组后按enter)\n"); scanf("%d,%d,%d",&M.date[p].a,&M.date[p].b,&M.date[p].e);while(M.date[p].a!=0){ p++;scanf("%d,%d,%d",&M.date[p].a,&M.date[p].b,&M.date[p].e); } M.tu=p-1;printf("非零元素的个数为:%d\n",M.tu);printf("输出M矩阵:\n");p=1;for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++) if(i==M.date[p].a&&j==M.date[p].b)printf("%6d",M.date[p++].e);else printf("%6c",'0'); printf("\n"); }//实现转置T.mu=M.nu; T.nu=M.mu; T.tu=M.tu;for(col=1;col<=M.nu;++col)for(p=1;p<=M.tu;p++)if(M.date[p].b==col) { T.date[q].a=M.date[p].b;T.date[q].b=M.date[p].a; T.date[q].e=M.date[p].e; q++; }printf("输出转置矩阵T:\n"); p=1;for(i=1;i<=T.mu;i++){ for(j=1;j<=T.nu;j++)if(i==T.date[p].a&&j==T.date[p].b) printf("%6d",T.date[p++].e);else printf("%6c",'0'); printf("\n"); }实验结果分析:本章节的程序需要熟读课本后才能编写,其中第一、第二个程序相对简单。
串-数据结构实验报告
串-数据结构实验报告串数据结构实验报告一、实验目的本次实验的主要目的是深入理解和掌握串这种数据结构的基本概念、存储方式以及相关的操作算法。
通过实际编程实现串的基本操作,提高对数据结构的理解和编程能力,培养解决实际问题的思维和方法。
二、实验环境本次实验使用的编程语言为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算法的少。
数据结构串实验报告
数据结构串实验报告数据结构串实验报告引言:数据结构是计算机科学中的重要概念之一,它研究如何组织和存储数据,以便能够高效地访问和操作。
串是一种特殊的数据结构,它由一系列字符组成,可以用来表示文本、字符串等信息。
本实验旨在通过实现串的基本操作,深入理解数据结构的原理和应用。
一、实验目的本实验的主要目的是掌握串的基本操作,包括串的初始化、插入、删除、查找等。
通过实际编程实现这些操作,可以加深对数据结构的理解,并提高编程能力。
二、实验环境本实验使用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语句进行选择判断,并用类的对象调用类的成员函数以实现特定的功能。
《数据结构》实验三【 串的基本操作】
if(s[n]!=t[n])
{
m=t[n]-s[n];
printf(" %d\n",m);
break;
}
if(m==0)
{
m=i-j;
printf(" %d\n",m);
}
}
void Concat(char s[ ]) //串的连接
{
char t[MAXSTRLEN],l[MAXSTRLEN];
case 3: StrCompare(s);break;
case 4: Concat(s);break;
case 5:Index(s);brou want to continue?\n");
printf("------------- ");
do{
scanf("%c",&continue_or);
void PrintMenu( )//菜单函数输出显示
{
printf("*******************************************\n");
printf("******** 1.Copy existing string********\n");
printf("******** 2.String length********\n");
实验
类型
设计型
综合型
创新型
√
实
验
目
的
或
要
求
实验目的:
掌握串的结构以及基本操作。
数据结构串和数组
数据结构串和数组数据结构是计算机科学中的一个重要概念,它是指一种组织和存储数据的方式。
而数组是一种基本的数据结构,它是由相同类型的元素组成的有限序列。
本文将以数据结构串和数组为标题,探讨它们的定义、特性以及应用。
一、数据结构串的定义与特性数据结构串是由一系列字符组成的有限序列。
它是一种线性结构,可以通过下标访问其中的元素。
串的长度是其中字符的个数,可以为空串。
串的主要特性包括以下几点:1. 顺序存储:串可以使用数组来进行顺序存储,即将字符依次存放在一块连续的内存空间中。
这样可以方便地通过下标来访问和修改串中的元素。
2. 动态存储:为了适应不同长度的串,可以使用动态数组来存储串。
动态数组可以根据需要自动扩容或缩容,以节省内存空间。
3. 字符操作:串的元素是字符,可以对串进行字符操作,如插入、删除、替换等。
这些操作可以通过数组的下标来实现。
4. 字符串匹配:串的匹配是串算法中的一个重要问题。
常见的匹配算法有朴素匹配算法、KMP算法、Boyer-Moore算法等。
这些算法的基本思想是通过比较字符来确定匹配位置,而数组的下标操作可以快速访问串中的字符。
二、数组的定义与特性数组是一种基本的数据结构,它是由相同类型的元素组成的有限序列。
数组的定义包括以下几点:1. 类型:数组中的元素必须具有相同的数据类型,可以是基本类型、结构体或指针类型。
2. 大小:数组的大小是固定的,一旦定义后,就不能改变。
数组的大小由元素的个数决定,可以为空数组。
3. 下标:数组的元素可以通过下标(索引)来访问,下标从0开始,依次递增。
通过下标可以快速定位和修改数组中的元素。
4. 存储:数组的元素在内存中是连续存储的,可以通过计算偏移量来访问数组中的元素。
这样可以提高访问效率。
5. 多维数组:数组可以是多维的,即由多个维度组成。
多维数组可以用于表示矩阵、图等复杂的数据结构。
数据结构串和数组在计算机科学中有广泛的应用。
下面介绍一些常见的应用场景:1. 字符串处理:串的操作是字符串处理中的基础操作。
数据结构实验指导书含答案模板
数据结构实验指导书含答案《数据结构》实验指导书专业:__电子商务___班级:___ 级电商2班_____组序:_____________学号:__12134675_____姓名:____王苏桐____中国矿业大学管理学院年 12 月上篇程序设计基础实验一 Java编程环境【实验目的】1.掌握下载Java sdk软件包、Eclipse软件的安装和使用方法2.掌握设置Java程序运行环境的方法3.掌握编写与运行Java程序的方法4.了解Java语言的概貌【实验内容】一 JDK下载与安装1. 下载JDK为了建立基于SDK的Java运行环境,需要先下载免费SDK软件包。
SDK包含了一整套开发工具,其中包含对编程最有用的是Java编译器、Applet查看器和Java解释器。
下载链接。
2.安装SDK运行下载的JDK软件包,在安装过程中能够设置安装路径及选择组件,默认的组件选择是全部安装,安装成功后,其中bin文件夹中包含编译器(javac.exe)、解释器(java.exe)、Applet查看器(appletviewer.exe)等可执行文件,lib文件夹中包含了所有的类库以便开发Java程序使用,demo文件夹中包含开源代码程序实例。
安装成功后,文件和子目录结构如图1所示。
其中bin文件夹中包含编译器(javac.exe)、解释器(java.exe)、Applet查看器(appletviewer.exe)等可执行文件,lib文件夹中包含了所有的类库以便开发Java程序使用,sample文件夹包含开源代码程序实例,src压缩文件中包含类库开源代码。
图1二.设置环境变量JDK中的工具都是命令行工具,需要从命令行即MS-DOS提示符下运行它们。
很多人可能会不习惯,但这是Sun特意采取的策略,为的是把精力更多投入到Java语言本身而不是花在开发工具上。
以Windows XP 为例说明设置过程。
右击桌面“我的电脑”图标,选择“属性”菜单图 2在“高级”选项卡中单击“环境变量”按钮,将出现“环境变量”设置界面图 3在“系统变量”框中点击“新建”按钮,在出现的“编辑系统变量”对话框中,在“变量名”栏的文本框内输入“JavaHome”,在变量值栏的文本框内输入jdk安装的主目录。
数据结构_实验3_串和数组
实验3 串和数组的相关操作一,实验目的理解并掌握串的逻辑结构和定长顺序存储方式;理解串的相关基本算法;编程对相关算法进行验证。
理解数组的逻辑结构和顺序存储方式;掌握对称矩阵和稀疏矩阵的压缩存储方法;掌握稀疏矩阵的三元组顺序表表示法和快速转置运算。
二,实验内容3.1 串的模式匹配运算编写一个程序,实现顺序串的各种模式匹配运算,并在此基础上设计主程序完成如下功能:(1)建立目标串s=‘abcabcdabcdeabcdefabcdefg’和模式串t=‘abcdeabcdefab’;(2)采用简单模式匹配算法求t在s中的位置;(3)由模式串t求出next值和nextval值;(4)采用KMP算法求t在s中的位置;(5)采用改进的KMP算法求t在s中的位置。
3.2 数组的操作1.建立一个n*n的对称矩阵A;用动态分配的一维数组B对矩阵A进行压缩存储,输出矩阵A和一维数组B;2.在B中查找对称矩阵A中第row行,第col列(下标从1开始)的元素,输出该元素值;3.建立一个稀疏矩阵C,输入其行数,列数和非零元个数,用三元组顺序表存储该矩阵,并按矩阵形式输出稀疏矩阵B;4.对稀疏矩阵C做快速转置运算得到矩阵D,并按矩阵形式输出转置后的矩阵D。
【要求】1.矩阵元素相关信息要从终端输入;2.在三元组顺序表中按行优先顺序存放非零元素;3.具体的输入和输出格式不限;4.算法要具有较好的健壮性,对错误操作要做适当处理。
三,源代码及结果截图3.1#include<stdio.h>#include<string.h>#include<malloc.h>#define MaxSize 100typedef struct {char data[MaxSize]; //定义可容纳MaxSize个字符的空间 int length; //标记当前实际串长}SqString;void StrAssign(SqString &str,char cstr[]){ //由串常量cstr创建串strint i;for(i=0;cstr[i]!='\0';i++)str.data[i]=cstr[i];str.length=i;}void DispStr(SqString s){ //输出串s的所有元素int i;if(s.length>0){for(i=0;i<s.length;i++)printf("%c",s.data[i]);printf("\n");}}int Index(SqString s,SqString t){ //简单匹配算法int i=0,j=0,k;while(i<s.length && j<t.length){if(s.data[i]==t.data[j]){ //继续匹配下一个字符i++;j++;}else{ //主串、子串指针回溯重新开始下一次匹配i=i-j+1;j=0;}}if(j>=t.length)k=i-t.length; //返回匹配的第一个字符的下标 elsek=-1; //模式匹配不成功return k;}void GetNext(SqString t,int next[]){ //由模式串t求出next值int j,k;j=0;k=-1;next[0]=-1;while(j<t.length-1){if(k==-1 || t.data[j]==t.data[k]){j++;k++;next[j]=k;}elsek=next[k];}}void GetNextval(SqString t,int nextval[]){ //由模式串t求出nextval值int j=0,k=-1;nextval[0]=-1;while(j<t.length){if(k==-1 || t.data[j]==t.data[k]){j++;k++;if(t.data[j]!=t.data[k])nextval[j]=k;elsenextval[j]=nextval[k];}else k=nextval[k];}}int KMPIndex(SqString s,SqString t){ //KMP算法int next[MaxSize],i=0,j=0,v;GetNext(t,next);while(i<s.length && j<t.length){if(j==-1 || s.data[i]==t.data[j]){i++;j++;}elsej=next[j]; //i不变,j后退}if(j>=t.length)v=i-t.length; //返回匹配模式串的首字符下标 elsev=-1; //返回不匹配标志return v;}int KMPIndex1(SqString s,SqString t){ //改进的KMP算法int nextval[MaxSize],next[MaxSize],i=0,j=0,v;GetNextval(t,next);GetNextval(t,nextval);while(i<s.length && j<t.length){if(j==-1 || s.data[i]==t.data[j]){i++;j++;}elsej=nextval[j];}if(j>=t.length)v=i-t.length; //返回匹配模式串的首字符下标elsev=-1;return v;}int main(){int j;int next[MaxSize],nextval[MaxSize];SqString s,t;StrAssign(s,"abcabcdabcdeabcdefabcdefg");StrAssign(t,"abcdeabcdefab");printf("目标串s:");DispStr(s);printf("模式串t:");DispStr(t);printf("简单匹配P算法:\n");printf("t在s中的位置=%d\n",Index(s,t));GetNext(t,next); //由模式串t求出next值GetNextval(t,nextval); //由模式串t求出nextval值 printf(" j ");for(j=0;j<t.length;j++)printf("%d",j);printf("\n");printf("t[j] ");for(j=0;j<t.length;j++)printf("%c",t.data[j]);printf("\n");printf("next ");for(j=0;j<t.length;j++)printf("%d",next[j]);printf("\n");printf("nextval");for(j=0;j<t.length;j++)printf("%d",nextval[j]);printf("\n");printf("KMP算法:\n");printf("t在s中的位置=%d\n",KMPIndex(s,t));printf("改进的KMP算法:\n");printf("t在s中的位置=%d\n",KMPIndex1(s,t));return 0;}结果截图:3.2#include<string.h>#include<ctype.h>#include<malloc.h> //malloc( )#include<limits.h> // INT ,MAX#include<stdio.h> //EOF,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//OVERFLOW 在 math.h 中已定义为3typedef int Status;typedef int Boolean; // 布尔类型#define MAXSIZE 100typedef int ElemType;typedef struct {int i,j;ElemType e;}Triple ;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}TSMatrix;typedef struct{ElemType ms[MAXSIZE][MAXSIZE];int line;}MMatrix;ElemType B[(MAXSIZE+1)*50+1];void PrinTMMatrix(MMatrix M){int i,j;for (i=1;i<=M.line;i++){for (j=1;j<=M.line;j++){printf("%d\t",M.ms[i][j]);}putchar('\n');}}Status CreateMatrix(MMatrix &M){int i,j;printf("输入行数,行和列相等:\n");scanf("%d",&M.line);for (i=1;i<=M.line;i++){printf("输入第%d行数据:\n",i);for (j=1;j<=M.line;j++){scanf("%d",&M.ms[i][j]);}}printf("输出矩阵A:\n");PrinTMMatrix(M);return OK;}Status GetMMValue(MMatrix M,ElemType &e) {int i,j;printf("请输入要查找的行号,列号:\n");fflush(stdin);scanf("%d%d",&i,&j);if (i>M.line||j>M.line){printf("已经越界,无法取值\n");return ERROR;}else{int k;if (i>=j){k = i*(i-1)/2+j;}elsek=j*(j-1)/2+i;e = B[k];printf("取出的值为:%d\n",e);}return OK;}Status CutMMatrix(MMatrix &M){int i,j;for (i=1;i<=M.line;i++){for (j=i+1;j<=M.line;j++){if (M.ms[i][j]!=M.ms[j][i]){printf("不是对称矩阵请重新输入:\n");CreateMatrix(M);CutMMatrix(M);return OK;}}}printf("输出一维数组B:\n");int k=1;for (i=1;i<=M.line;i++){for (j=1;j<=i;j++){B[k++] = M.ms[i][j];printf("%d%d\t",B[k-1],M.ms[i][j]);}}printf("\n");return OK;}Status InitMatirx(TSMatrix &T){int i;T.tu = 1;printf("建立稀疏矩阵C:\n");printf("输入行数,列数,输入三元组个数\n");scanf("%d%d%d",&T.mu,&T.nu,&T.tu);for (i=1;i<=T.tu;i++){printf("输入第%d组三元组行号,列号,值(请按照行优先顺序)\n",i);scanf("%d%d%d",&T.data[i].i,&T.data[i].j,&T.data[i].e);}return OK;;}void PrintMatrix(TSMatrix T){int i,j,k=1;for(i=1;i<=T.mu;i++){for(j=1;j<=T.nu;j++){if(T.data[k].i==i&&T.data[k].j==j){printf("%d\t",T.data[k].e);k++;}else{printf("%d\t",0);}}printf("\n");}}int FastTransposeMatrix(TSMatrix M,TSMatrix &T){int col,t,p,q;int num[20],cpot[20];cpot[1] =1;T.mu = M.nu ;T.nu = M.mu ;T.tu = M.tu ;if(T.tu){for(col=1;col<=M.nu;col++)num[col] = 0;for(t=1;t<=M.tu;t++)++num[M.data[t].j];for(col=2;col<=M.nu;col++)cpot[col]=cpot[col-1]+num[col-1];for(p=1;p<=M.tu;p++){col = M.data[p].j;q = cpot[col];T.data[q].i = M.data[p].j;T.data[q].j = M.data[p].i;T.data[q].e = M.data[p].e;++cpot[col];}}return 1;}main(){MMatrix A;CreateMatrix(A);CutMMatrix(A);ElemType e;GetMMValue(A,e);TSMatrix B,D;InitMatirx(B);printf("输出稀疏矩阵B:\n");PrintMatrix(B);printf("\n转置后的矩阵D:\n");FastTransposeMatrix(B,D);PrintMatrix(D);}结果截图:四,小结(1)本次实验的程序需要熟读课本后才能编写,其中第一个程序相对简单。
实验三.数组与字符串
1.实验三数组与字符串一、实验目的:1.熟悉Java的数组的使用,编程练习数组声明、定义、遍历和排序等操作。
2.熟悉Java的字符串相关类的使用,通过编程实现针对字符串的一般操作。
二、实验内容:1.定义一个有10个元素的整型数组,找出最大最小值;2.定义一个有10个元素的整型数组,用选择法实现由小到大排序;3.定义一个能实现冒泡法排序的方法bSort(int[] arr),然后定义并初始化一4*5的二维数组,用bSort(int[] arr)将该二维数组的每行元素进行升序排序;4.编程求解一个3*3矩阵每一行的元素之和,每一列元素之和,对角线元素之和,并输出。
5.接收键盘输入的字符串,使用String类的方法indexOf()来统计该字符串中各个字符出现的次数。
6.设定并初始化一个字符串数组,并将数组中那些以字母b开头的元素打印出来。
7.接收键盘输入的字符串,分别按顺序输出该字符串中的大写字符和小写字符。
8.接收键盘输入的英文字符串(单词之间用空格隔开),将字符串中出现的单词首字母改成大写后输出。
三、实验要求:1.通过实验掌握数组的定义和初始化;2.掌握数组最值求解算法;3.掌握数组的基本排序算法;4.掌握遍历数组的算法;5.通过实验掌握String类的使用;6.通过实验掌握String类常用方法的使用;7.从JDK文档中查阅String类的以下方法(与本实验内容相关):split(),startWith(),toUpperCase(),indexOf(),charAt(),并说明它们的用法;8.写出实验报告。
四、实验学时:3学时五、实验步骤:1.进入Java编程环境;2.新建一个Java文件,编写main()方法实现一维数组求最值的算法;3.新建一个Java文件,编写main()方法实现一维数组选择法排序算法;4.新建一个Java类,定义bSort(int[] arr)方法(冒泡法)实现数组升序排序,然后在main方法里实现对一4*5二维数组每行元素的升序排序;5.新建一个Java文件,编写main()方法声明并初始化一两维3*3数组,设计算法实现行、列和对角线元素的求和操作;6.编写主方法main(),其中实现接收键盘输入功能、文件操作功能和文件内容输出功能;7.调用相应构造方法创建String对象;8.查阅JDK文档,找出可以实现实验内容的String方法,设计算法,编写程序;9.调试运行程序,观察输出结果。
计算机软件基础课件-2017-第2章-3-串和数组
串匹配(查找)的定义
Index (S, T, int pos)
初始条件:串S和T存在,T是非空串, 1≤pos≤StrLength(S)。
操作结果:若主串S中存在和串T值相同的子串返回它在主串S 中第pos个字符之后第一次出现的位置,否则函数值为-1。
25
简单模式匹配算法举例
绪论中的例-4:
T->str[i]=S.str[i-T->length]; flag=0; } else { T->length=MAXSTRLEN;//情况3 flag=0; } return flag; }
20
2.串的链式存储表示——链串
链串中每个结点有两个域: • 一个是数据域(data),用于存放字符串中的字符, • 另一个是指针域(next),用于存放后继结点的地址。
ANSI编码间互不兼容)
– UNICODE(国际化,各种语言中的每一个字符具有唯一 的数字编号,便于跨平台的文本转换)
中文字符串有些特例,例如“笔划”序
7
两个串之间可以比较:
如 S1=”a1a2a3…am”和S2=”b1b2b3…bn”, 首先比较第一个字符的大小,若”a1”<”b1”,则S1<S2,
14
串的逻辑结构和线性表极为相似,区别仅在于串的数据对象约束为 字符集。
但串的基本操作和线性表有很大差别: ➢ 在线性表的基本操作中,大多以“单个元素”
作为操作对象; ➢ 在串的基本操作中,通常以“串的整体”作
为操作对象。
15
串的表示和实现
• 在程序设计语言中,串只是作为输入或输出的常量出现,则只需 存储此串的串值,即字符序列即可。但在多数非数值处理的程序 中,串也以变量的形式出现。
实验三:数组与字符串操作
实验三:数组与字符串操作实验目的●掌握Java字符串和数组的基本操作。
●学习如何通过组合字符串和数组来解决实际问题。
●提高处理字符串数据的能力,理解如何将字符串数据转换为数组进行操作。
实验内容编写一个Java程序,用于处理字符串数据,将其转换为数组并进行处理。
具体任务如下:实验要求1. 程序功能:●提示用户输入一行文本(以空格分隔的单词)。
●将输入的文本按照空格分割,存储在字符串数组中。
●统计数组中每个单词的长度,并将结果存储在对应的整数数组中。
●输出每个单词及其对应的长度。
2. 程序结构:●使用Scanner类获取用户输入。
●使用String类的split()方法将输入文本转换为字符串数组。
●使用循环遍历数组,计算每个单词的长度,并将其存储到整数数组中。
●输出结果,显示每个单词及其长度。
3. 代码规范:●遵循Java命名规范。
●代码应具有良好的可读性,合理使用注释。
●确保代码格式整洁,适当使用空格和缩进。
4. 错误处理:●确保程序能够处理空输入或仅包含空格的输入。
●对用户的错误输入给出适当的提示。
5. 用户交互:●程序应提供清晰的用户提示信息,帮助用户理解如何输入数据。
实验步骤1.创建一个新的Java项目,并在其中创建一个名为WordLengthProcessor.java的类文件。
2.在WordLengthProcessor.java中编写主程序,实现上述要求。
3.编译并运行程序,测试是否能够正确处理用户输入的字符串并计算每个单词的长度。
4.对程序进行调试,确保所有异常情况都能得到妥善处理。
提交内容●完整的WordLengthProcessor.java源代码。
●程序运行截图,展示程序能够正常工作。
●程序的简单使用说明,三者整合到一个文档中。
示例输入:"hello world this is Java"输出:单词:hello,长度:5单词:world,长度:5单词:this,长度:4单词:is,长度:2单词:Java,长度:4实验截止日期请在实验截止日期前完成实验,并提交上述要求的所有内容。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验3 串和数组的相关操作一,实验目的理解并掌握串的逻辑结构和定长顺序存储方式;理解串的相关基本算法;编程对相关算法进行验证。
理解数组的逻辑结构和顺序存储方式;掌握对称矩阵和稀疏矩阵的压缩存储方法;掌握稀疏矩阵的三元组顺序表表示法和快速转置运算。
二,实验内容3.1 串的模式匹配运算编写一个程序,实现顺序串的各种模式匹配运算,并在此基础上设计主程序完成如下功能:(1)建立目标串s=‘abcabcdabcdeabcdefabcdefg’和模式串t=‘abcdeabcdefab’;(2)采用简单模式匹配算法求t在s中的位置;(3)由模式串t求出next值和nextval值;(4)采用KMP算法求t在s中的位置;(5)采用改进的KMP算法求t在s中的位置。
3.2 数组的操作1.建立一个n*n的对称矩阵A;用动态分配的一维数组B对矩阵A进行压缩存储,输出矩阵A和一维数组B;2.在B中查找对称矩阵A中第row行,第col列(下标从1开始)的元素,输出该元素值;3.建立一个稀疏矩阵C,输入其行数,列数和非零元个数,用三元组顺序表存储该矩阵,并按矩阵形式输出稀疏矩阵B;4.对稀疏矩阵C做快速转置运算得到矩阵D,并按矩阵形式输出转置后的矩阵D。
【要求】1.矩阵元素相关信息要从终端输入;2.在三元组顺序表中按行优先顺序存放非零元素;3.具体的输入和输出格式不限;4.算法要具有较好的健壮性,对错误操作要做适当处理。
三,源代码及结果截图3.1#include<stdio.h>#include<string.h>#include<malloc.h>#define MaxSize 100typedef struct {char data[MaxSize]; //定义可容纳MaxSize个字符的空间 int length; //标记当前实际串长}SqString;void StrAssign(SqString &str,char cstr[]){ //由串常量cstr创建串strint i;for(i=0;cstr[i]!='\0';i++)str.data[i]=cstr[i];str.length=i;}void DispStr(SqString s){ //输出串s的所有元素int i;if(s.length>0){for(i=0;i<s.length;i++)printf("%c",s.data[i]);printf("\n");}}int Index(SqString s,SqString t){ //简单匹配算法int i=0,j=0,k;while(i<s.length && j<t.length){if(s.data[i]==t.data[j]){ //继续匹配下一个字符i++;j++;}else{ //主串、子串指针回溯重新开始下一次匹配i=i-j+1;j=0;}}if(j>=t.length)k=i-t.length; //返回匹配的第一个字符的下标 elsek=-1; //模式匹配不成功return k;}void GetNext(SqString t,int next[]){ //由模式串t求出next值int j,k;j=0;k=-1;next[0]=-1;while(j<t.length-1){if(k==-1 || t.data[j]==t.data[k]){j++;k++;next[j]=k;}elsek=next[k];}}void GetNextval(SqString t,int nextval[]){ //由模式串t求出nextval值int j=0,k=-1;nextval[0]=-1;while(j<t.length){if(k==-1 || t.data[j]==t.data[k]){j++;k++;if(t.data[j]!=t.data[k])nextval[j]=k;elsenextval[j]=nextval[k];}else k=nextval[k];}}int KMPIndex(SqString s,SqString t){ //KMP算法int next[MaxSize],i=0,j=0,v;GetNext(t,next);while(i<s.length && j<t.length){if(j==-1 || s.data[i]==t.data[j]){i++;j++;}elsej=next[j]; //i不变,j后退}if(j>=t.length)v=i-t.length; //返回匹配模式串的首字符下标 elsev=-1; //返回不匹配标志return v;}int KMPIndex1(SqString s,SqString t){ //改进的KMP算法int nextval[MaxSize],next[MaxSize],i=0,j=0,v;GetNextval(t,next);GetNextval(t,nextval);while(i<s.length && j<t.length){if(j==-1 || s.data[i]==t.data[j]){i++;j++;}elsej=nextval[j];}if(j>=t.length)v=i-t.length; //返回匹配模式串的首字符下标elsev=-1;return v;}int main(){int j;int next[MaxSize],nextval[MaxSize];SqString s,t;StrAssign(s,"abcabcdabcdeabcdefabcdefg");StrAssign(t,"abcdeabcdefab");printf("目标串s:");DispStr(s);printf("模式串t:");DispStr(t);printf("简单匹配P算法:\n");printf("t在s中的位置=%d\n",Index(s,t));GetNext(t,next); //由模式串t求出next值GetNextval(t,nextval); //由模式串t求出nextval值 printf(" j ");for(j=0;j<t.length;j++)printf("%d",j);printf("\n");printf("t[j] ");for(j=0;j<t.length;j++)printf("%c",t.data[j]);printf("\n");printf("next ");for(j=0;j<t.length;j++)printf("%d",next[j]);printf("\n");printf("nextval");for(j=0;j<t.length;j++)printf("%d",nextval[j]);printf("\n");printf("KMP算法:\n");printf("t在s中的位置=%d\n",KMPIndex(s,t));printf("改进的KMP算法:\n");printf("t在s中的位置=%d\n",KMPIndex1(s,t));return 0;}结果截图:3.2#include<string.h>#include<ctype.h>#include<malloc.h> //malloc( )#include<limits.h> // INT ,MAX#include<stdio.h> //EOF,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//OVERFLOW 在 math.h 中已定义为3typedef int Status;typedef int Boolean; // 布尔类型#define MAXSIZE 100typedef int ElemType;typedef struct {int i,j;ElemType e;}Triple ;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}TSMatrix;typedef struct{ElemType ms[MAXSIZE][MAXSIZE];int line;}MMatrix;ElemType B[(MAXSIZE+1)*50+1];void PrinTMMatrix(MMatrix M){int i,j;for (i=1;i<=M.line;i++){for (j=1;j<=M.line;j++){printf("%d\t",M.ms[i][j]);}putchar('\n');}}Status CreateMatrix(MMatrix &M){int i,j;printf("输入行数,行和列相等:\n");scanf("%d",&M.line);for (i=1;i<=M.line;i++){printf("输入第%d行数据:\n",i);for (j=1;j<=M.line;j++){scanf("%d",&M.ms[i][j]);}}printf("输出矩阵A:\n");PrinTMMatrix(M);return OK;}Status GetMMValue(MMatrix M,ElemType &e) {int i,j;printf("请输入要查找的行号,列号:\n");fflush(stdin);scanf("%d%d",&i,&j);if (i>M.line||j>M.line){printf("已经越界,无法取值\n");return ERROR;}else{int k;if (i>=j){k = i*(i-1)/2+j;}elsek=j*(j-1)/2+i;e = B[k];printf("取出的值为:%d\n",e);}return OK;}Status CutMMatrix(MMatrix &M){int i,j;for (i=1;i<=M.line;i++){for (j=i+1;j<=M.line;j++){if (M.ms[i][j]!=M.ms[j][i]){printf("不是对称矩阵请重新输入:\n");CreateMatrix(M);CutMMatrix(M);return OK;}}}printf("输出一维数组B:\n");int k=1;for (i=1;i<=M.line;i++){for (j=1;j<=i;j++){B[k++] = M.ms[i][j];printf("%d%d\t",B[k-1],M.ms[i][j]);}}printf("\n");return OK;}Status InitMatirx(TSMatrix &T){int i;T.tu = 1;printf("建立稀疏矩阵C:\n");printf("输入行数,列数,输入三元组个数\n");scanf("%d%d%d",&T.mu,&T.nu,&T.tu);for (i=1;i<=T.tu;i++){printf("输入第%d组三元组行号,列号,值(请按照行优先顺序)\n",i);scanf("%d%d%d",&T.data[i].i,&T.data[i].j,&T.data[i].e);}return OK;;}void PrintMatrix(TSMatrix T){int i,j,k=1;for(i=1;i<=T.mu;i++){for(j=1;j<=T.nu;j++){if(T.data[k].i==i&&T.data[k].j==j){printf("%d\t",T.data[k].e);k++;}else{printf("%d\t",0);}}printf("\n");}}int FastTransposeMatrix(TSMatrix M,TSMatrix &T){int col,t,p,q;int num[20],cpot[20];cpot[1] =1;T.mu = M.nu ;T.nu = M.mu ;T.tu = M.tu ;if(T.tu){for(col=1;col<=M.nu;col++)num[col] = 0;for(t=1;t<=M.tu;t++)++num[M.data[t].j];for(col=2;col<=M.nu;col++)cpot[col]=cpot[col-1]+num[col-1];for(p=1;p<=M.tu;p++){col = M.data[p].j;q = cpot[col];T.data[q].i = M.data[p].j;T.data[q].j = M.data[p].i;T.data[q].e = M.data[p].e;++cpot[col];}}return 1;}main(){MMatrix A;CreateMatrix(A);CutMMatrix(A);ElemType e;GetMMValue(A,e);TSMatrix B,D;InitMatirx(B);printf("输出稀疏矩阵B:\n");PrintMatrix(B);printf("\n转置后的矩阵D:\n");FastTransposeMatrix(B,D);PrintMatrix(D);}结果截图:四,小结(1)本次实验的程序需要熟读课本后才能编写,其中第一个程序相对简单。