数据结构实验报告3--链串
数据结构3-串及其应用.
实验3:串及其应用一、实验目的掌握串类型的实现方法和文本模式匹配方法,熟悉一般文字处理软件的设计方法。
二、问题描述全屏幕文本编辑器通过终端对文本文件进行创建、插入、删除、修改、存储等操作。
用户可完成对文本的插入、删除、修改等功能。
三、实验要求1、对光标实现如下操作:上、下、左、右移动一个字符位置;向前、后翻页;光标移至文件首、尾;光标移至本行首、尾。
2、实现基本编辑命令:I----在当前光标前插入内容,按ESC结束F----在当前光标后插入内容,按ESC结束D----删除光标所在行ND---删除光标位置开始的n行N-----删除光标上的字符W----将修改后的文本保存下来Q----退出编辑状态。
四、实验环境PC微机DOS操作系统或Windows 操作系统Turbo C 程序集成环境或Visual C++ 程序集成环境五、实验步骤1、在内存开辟可容纳80行大小的编辑工作区和buffer 的修改缓冲区。
2、要求用户输入编辑文件名,对读入的文件建立相应的页表和行表,在文本编辑程序中设立页指针、行指针、字符指针,分别指示当前操作的页、行、字符。
3、执行插入、删除、修改操作时,将本次操作内容放到缓冲区;4、操作确定后,将修改后的文本存到文件中。
六、测试数据自行设定。
七、实验报告要求实验报告应包括以下几个部分:1、问题描述;2、算法的设计描述;3、测试结果的分析与讨论。
4、设计与实现过程中的体会,进一步的改进设想。
5、实验总结。
八、思考题1、对命令格式非法等错误做严格检查和适当处理。
2、扩充编辑操作,如对某行进行串替换?。
数据结构 串 实验报告
实验报告实验名称:串实验目的:(1)、熟悉C语言的上机环境,进一步掌握C语言的结构特点;(2)、掌握串的定义及C语言实现;(3)、掌握串的模式匹配及C语言实现;(4)、掌握串的各种基本操作;实验步骤:(1)、建立链串类型(2)、实现匹配过程中需考虑的链表的特征。
实验内容:4.一个字符串中的任意一个子序列,若子序列中各字符值均相同,则成为字符平台。
写一算法,输入任意以字符串S,输出S中长度最大的所有字符平台的起始位置及所含字符。
注意,最大字符平台有可能不止一个。
实验数据记录:(源代码及执行过程)#include<stdio.h>#include<stdlib.h>#define Maxsize 20#define n 100typedef struct Node{int element[Maxsize];int front;int rear;}Queue;int EnterQueue(Queue *Q,int x){if((Q->rear+1)%Maxsize == Q->front){printf("队列已满!\n");return 0;}Q->element[Q->rear] = x;Q->rear = (Q->rear+1)%Maxsize;return 1;}int DeleQueue(Queue *Q,int *x){if(Q->front == Q->rear){printf("队列为空!\n");return 0;}*x = Q->element[Q->front];Q->front = (Q->front+1)%Maxsize;return 1;}int Donull(Queue *Q){while(Q->front != Q->rear){Q->element[Q->front] = 0;Q->front = (Q->front+1)%Maxsize;}Q->front = Q->rear = 0;if(Q->front == Q->rear){return 1;}else{return 0;}}int main(void){char str[n];int i=0,j=1,k=1,ch,p=1,flag=1;Queue *Q;Q = (Queue *)malloc(sizeof(Queue));Q->front = Q->rear = 0;printf("请输入字符串:");gets(str);while('\0' != *(str+i)){ while(*(str+i+1) == *(str+i)){if(flag){p = i;flag = 0;}i++;j++;}if(flag){p = i;}if(j >= k){if(j > k){Donull(Q);k = j;}if(EnterQueue(Q ,j) == 0)break;if(EnterQueue(Q,p+1) == 0)break;if(EnterQueue(Q,*(str+i)) == 0)break;}j=1;i++;flag = 1;} while(Q->front < Q->rear){DeleQueue(Q,&j);DeleQueue(Q,&k);DeleQueue(Q,&ch);printf("%-10d",k);for(i = 0; i < j; i++){printf("%c",ch);}printf("\n");}printf("\n");system("pause");}。
数据结构实验报告串
数据结构实验报告串数据结构实验报告串一、引言数据结构是计算机科学的基础,它研究数据的组织、存储和管理方式。
在本次实验中,我们将学习和实践一些常见的数据结构,如链表、栈和队列。
通过实验,我们将深入了解这些数据结构的特点、优势和应用场景。
二、链表链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表可以分为单向链表和双向链表两种类型。
在实验中,我们实现了一个简单的单向链表,并进行了一系列操作,如插入、删除和遍历。
通过实验,我们发现链表的插入和删除操作时间复杂度为O(1),这是因为链表的节点可以通过指针直接连接,而不需要移动其他节点。
然而,链表的缺点是访问节点的时间复杂度为O(n),因为我们需要从头节点开始遍历链表直到找到目标节点。
三、栈栈是一种后进先出(LIFO)的数据结构,它只允许在栈顶进行插入和删除操作。
在实验中,我们实现了一个简单的栈,并进行了一系列操作,如入栈、出栈和获取栈顶元素。
通过实验,我们发现栈的插入和删除操作时间复杂度为O(1),这是因为栈的元素只能在栈顶进行操作。
栈的应用场景很广泛,例如函数调用和表达式求值。
在函数调用中,每次函数调用时,会将函数的返回地址和局部变量等信息存储在栈中,以便函数执行完毕后可以返回到正确的位置。
四、队列队列是一种先进先出(FIFO)的数据结构,它允许在队尾插入元素,在队头删除元素。
在实验中,我们实现了一个简单的队列,并进行了一系列操作,如入队、出队和获取队头元素。
通过实验,我们发现队列的插入和删除操作时间复杂度为O(1),这是因为队列的元素只能在队头和队尾进行操作。
队列的应用场景很多,例如任务调度和消息传递。
在任务调度中,每个任务都会被加入到队列中,然后按照先后顺序执行,确保任务按照正确的顺序完成。
五、实验总结通过本次实验,我们深入了解了链表、栈和队列这些常见的数据结构。
我们学习了它们的特点、优势和应用场景,并通过实践掌握了它们的基本操作。
C语言数据结构----链栈实验报告
#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int elemtype;typedef struct node{elemtype data;struct node *next;}node,*linkstack;linkstack *top;//链栈初始化node init_linkstack(){node top;top.next=NULL;return top;}//判栈空int linkstack_pankong(node top) {if(top.next==NULL)return 1;elsereturn 0;}//输出链栈元素void print_linkstack(node *top) {node *p;for(p=top->next;p;p=p->next){printf("%d\t",p->data);}}//入栈void puts_link(node *top,int a){node *p;p=(node *)malloc(sizeof(node));if(p==NULL){}else{p->data=a;p->next=top->next;top->next=p;}}//链栈逆序node nixu_link(node *a){node s,*r;s=init_linkstack();for(r=a->next;r;r=r->next){puts_link(&s,r->data);}return s;}//主函数部分void main(){elemtype x,i,n,a;node top;srand((unsigned)time(NULL));/*初始化链栈*/top=init_linkstack();printf("申请链栈内存空间成功\n");elemtype t;do{printf("\n\t请选择以下选项:\n\t1.生成链栈且输出\n\t2.将链栈逆序输出\n\t0.退出程序\n");printf("请输入对应选项:");scanf("%d",&t);switch(t){case 1:{printf("请输入需要生成随机数的数量: ");scanf("%d",&n);for(i=0;i<n;i++){a=rand()%50;puts_link(&top,a); //调用入栈函数,将随机数入栈}printf("链栈当前内容如下:\n");print_linkstack(&top);}continue;case 2:{if(linkstack_pankong(top)){printf("当前链栈内容是空的!");continue;}printf("链栈逆序输出为:\n");top=nixu_link(&top);print_linkstack(&top);}continue;case 0:break;}}while(t!=0);}。
串-数据结构实验报告
串-数据结构实验报告串数据结构实验报告一、实验目的本次实验的主要目的是深入理解和掌握串这种数据结构的基本概念、存储方式以及相关的操作算法。
通过实际编程实现串的基本操作,提高对数据结构的理解和编程能力,培养解决实际问题的思维和方法。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验原理(一)串的定义串是由零个或多个字符组成的有限序列。
在本次实验中,我们主要关注的是字符串。
(二)串的存储方式1、顺序存储定长顺序存储:使用固定长度的数组来存储字符串,长度不足时用特定字符填充。
堆分配存储:根据字符串的实际长度动态分配存储空间。
2、链式存储每个节点存储一个字符,并通过指针链接起来。
(三)串的基本操作1、串的创建和初始化2、串的赋值3、串的连接4、串的比较5、求子串6、串的插入和删除四、实验内容及步骤(一)顺序存储方式下串的实现1、定义一个结构体来表示顺序存储的字符串,包含字符数组和字符串的实际长度。
```cppstruct SeqString {char str;int length;};```2、实现串的创建和初始化函数```cppSeqString createSeqString(const char initStr) {int len = strlen(initStr);SeqString s;sstr = new charlen + 1;strcpy(sstr, initStr);slength = len;return s;}```3、串的赋值函数```cppvoid assignSeqString(SeqString& s, const char newStr) {delete sstr;int len = strlen(newStr);sstr = new charlen + 1;strcpy(sstr, newStr);slength = len;}```4、串的连接函数```cppSeqString concatSeqString(const SeqString& s1, const SeqString& s2) {SeqString result;resultlength = s1length + s2length;resultstr = new charresultlength + 1;strcpy(resultstr, s1str);strcat(resultstr, s2str);return result;}```5、串的比较函数```cppint compareSeqString(const SeqString& s1, const SeqString& s2) {return strcmp(s1str, s2str);}```6、求子串函数```cppSeqString subSeqString(const SeqString& s, int start, int len) {SeqString sub;sublength = len;substr = new charlen + 1;strncpy(substr, sstr + start, len);substrlen ='\0';return sub;}```7、串的插入函数```cppvoid insertSeqString(SeqString& s, int pos, const SeqString& insertStr) {int newLength = slength + insertStrlength;char newStr = new charnewLength + 1;strncpy(newStr, sstr, pos);strcpy(newStr + pos, insertStrstr);strcpy(newStr + pos + insertStrlength, sstr + pos);delete sstr;sstr = newStr;slength = newLength;}```8、串的删除函数```cppvoid deleteSeqString(SeqString& s, int start, int len) {int newLength = slength len;char newStr = new charnewLength + 1;strncpy(newStr, sstr, start);strcpy(newStr + start, sstr + start + len);delete sstr;sstr = newStr;slength = newLength;}```(二)链式存储方式下串的实现1、定义一个节点结构体```cppstruct LinkNode {char data;LinkNode next;LinkNode(char c) : data(c), next(NULL) {}};```2、定义一个链式存储的字符串类```cppclass LinkString {private:LinkNode head;int length;public:LinkString(const char initStr);~LinkString();void assign(const char newStr);LinkString concat(const LinkString& other);int compare(const LinkString& other);LinkString subString(int start, int len);void insert(int pos, const LinkString& insertStr);void deleteSub(int start, int len);};```3、实现各个函数```cppLinkString::LinkString(const char initStr) {length = strlen(initStr);head = NULL;LinkNode p = NULL;for (int i = 0; i < length; i++){LinkNode newNode = new LinkNode(initStri);if (head == NULL) {head = newNode;p = head;} else {p>next = newNode;p = p>next;}}}LinkString::~LinkString(){LinkNode p = head;while (p) {LinkNode temp = p;p = p>next;delete temp;}}void LinkString::assign(const char newStr) {//先释放原有的链表LinkNode p = head;while (p) {LinkNode temp = p;p = p>next;delete temp;}length = strlen(newStr);head = NULL;p = NULL;for (int i = 0; i < length; i++){LinkNode newNode = new LinkNode(newStri);if (head == NULL) {head = newNode;p = head;} else {p>next = newNode;p = p>next;}}}LinkString LinkString::concat(const LinkString& other) {LinkString result;LinkNode p1 = head;LinkNode p2 = otherhead;LinkNode p = NULL;while (p1) {LinkNode newNode = new LinkNode(p1->data);if (resulthead == NULL) {resulthead = newNode;p = resulthead;} else {p>next = newNode;p = p>next;}p1 = p1->next;}while (p2) {LinkNode newNode = new LinkNode(p2->data);if (resulthead == NULL) {resulthead = newNode;p = resulthead;} else {p>next = newNode;p = p>next;}p2 = p2->next;}resultlength = length + otherlength;return result;}int LinkString::compare(const LinkString& other) {LinkNode p1 = head;LinkNode p2 = otherhead;while (p1 && p2 && p1->data == p2->data) {p1 = p1->next;p2 = p2->next;}if (p1 == NULL && p2 == NULL) {return 0;} else if (p1 == NULL) {return -1;} else if (p2 == NULL) {return 1;} else {return p1->data p2->data;}}LinkString LinkString::subString(int start, int len) {LinkString sub;LinkNode p = head;for (int i = 0; i < start; i++){p = p>next;}for (int i = 0; i < len; i++){LinkNode newNode = new LinkNode(p>data);if (subhead == NULL) {subhead = newNode;} else {LinkNode temp = subhead;while (temp>next) {temp = temp>next;}temp>next = newNode;}p = p>next;}sublength = len;return sub;}void LinkString::insert(int pos, const LinkString& insertStr) {LinkNode p = head;for (int i = 0; i < pos 1; i++){p = p>next;}LinkNode insertHead = insertStrhead;while (insertHead) {LinkNode newNode = new LinkNode(insertHead>data);newNode>next = p>next;p>next = newNode;p = p>next;insertHead = insertHead>next;}length += insertStrlength;}void LinkString::deleteSub(int start, int len) {LinkNode p = head;for (int i = 0; i < start 1; i++){p = p>next;}LinkNode temp = p>next;for (int i = 0; i < len; i++){LinkNode delNode = temp;temp = temp>next;delete delNode;}p>next = temp;length = len;}```(三)测试用例1、顺序存储方式的测试```cppint main(){SeqString s1 = createSeqString("Hello");SeqString s2 = createSeqString("World");SeqString s3 = concatSeqString(s1, s2);std::cout <<"连接后的字符串: "<< s3str << std::endl; int cmpResult = compareSeqString(s1, s2);if (cmpResult < 0) {std::cout <<"s1 小于 s2" << std::endl;} else if (cmpResult == 0) {std::cout <<"s1 等于 s2" << std::endl;} else {std::cout <<"s1 大于 s2" << std::endl;}SeqString sub = subSeqString(s1, 1, 3);std::cout <<"子串: "<< substr << std::endl; insertSeqString(s1, 2, s2);std::cout <<"插入后的字符串: "<< s1str << std::endl; deleteSeqString(s1, 3, 2);std::cout <<"删除后的字符串: "<< s1str << std::endl; return 0;}```2、链式存储方式的测试```cppint main(){LinkString ls1("Hello");LinkString ls2("World");LinkString ls3 = ls1concat(ls2);std::cout <<"连接后的字符串: ";LinkNode p = ls3head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;int cmpResult = ls1compare(ls2);if (cmpResult < 0) {std::cout <<"ls1 小于 ls2" << std::endl;} else if (cmpResult == 0) {std::cout <<"ls1 等于 ls2" << std::endl;} else {std::cout <<"ls1 大于 ls2" << std::endl;}LinkString sub = ls1subString(1, 3);std::cout <<"子串: ";p = subhead;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;ls1insert(2, ls2);std::cout <<"插入后的字符串: ";p = ls1head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;ls1deleteSub(3, 2);std::cout <<"删除后的字符串: ";p = ls1head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;return 0;}```五、实验结果及分析(一)顺序存储方式1、连接操作成功实现,输出了正确连接后的字符串。
数据结构串实验报告
数据结构串实验报告实验报告课程数据结构实验名称实验三串学号姓名实验日期:实验三串实验目的:1. 熟悉串类型的实现方法,了解简单文字处理的设计方法;2. 熟悉C语言的字符和把字符串处理的原理和方法;3. 熟悉并掌握模式匹配算法。
实验原理:顺序存储结构下的关于字符串操作的基本算法。
模式匹配算法BF、KMP实验内容:4-19. 在4.4.3节例4-6的基础上,编写比较Brute-Force算法和KMP算法比较次数的程序。
4-20. 设串采用静态数组存储结构,编写函数实现串的替换Replace(S,start,T,V),即要求在主串S中,从位置start开始查找是否存在字串T。
若主串S中存在子串T,则用子串V替换子串T,且函数返回1;若主串S中不存在子串T,则函数返回0;并要求设计I am a student”,T=“student”,V=“teacher”。
主函数进行测试。
一个测试例子为:S=“程序代码:4-19的代码:/*静态存储结构*/typedef struct{char str[MaxSize];int length;}String;/*初始化操作*/void Initiate(String *S) {S->length=0;}/*插入子串操作 */int Insert(String *S, int pos, String T)/*在串S的pos位置插入子串T*/{int i;if(pos<0||pos>S->length){printf("The parameter pos is error!\n");return 0;}else if(S->length+T.length>MaxSize){printf("The space of the array is not enough!\n"); return 0;}else{for(i=S->length-1; i>=pos; i--)S->str[i+T.length]=S->str[i];/*依次后移数据元素*/for(i=0; i<T.length; i++)S->str[pos+i]=T.str[i]; /*插入*/S->length=S->length+T.length;/*产生新的串长度值*/return 1;}}/*删除子串操作 */int Delete(String *S, int pos, int len) /*删除串S的从pos位置开始长度为len的子串值*/{int i;if(S->length<=0){printf("No elements deleting!\n");return 0;}else if(pos<0||len<0||pos+len>S->length){printf("The parameters pos and len are not correct!\n"); return 0;}else{for(i=pos+len; i<=S->length-1; i++)S->str[i-len]=S->str[i];/*依次前移数据元素*/S->length=S->length-len;/*产生新的串长度值*/return 1;}}/*取子串操作 */int SubString(String S, int pos, int len, String *T)/*取串S的从pos位置开始长度为len的子串值赋给子串T*/ {int i;if(pos<0||len<0||pos+len>S.length){printf("The parameters pos and len are not correct!\n"); return 0;}else{for(i=0; i<=len; i++)T->str[i]=S.str[pos+i]; /*给子串T赋值*/T->length=len; /*给子串T的长度域赋值*/return 1;}}/*查找子串BF(Brute-Force)操作*/int BFIndex(String S, int start, String T)/*查找主串S从start开始的子串T,找到返回T在S中的开始字符下标,否则返回-1*/ {int i= start, j=0, v;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else{i=i-j+1;j=0;}}if(j==T.length)v=i-T.length;elsev=-1;return v;}/*查找子串KMP(D.E.Knuth-J.H.Morris-V.R.Pratt)操作 */ int KMPIndex(String S, int start, String T, int next[])/*查找主串S从start开始的子串T,找到返回T在S中的首字符下标,*/ /*否则返回-1*//*数组Next中存放有模式串T的next[j]值*/{int i= start, j=0, v;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else if(j==0) i++;else j=next[j];}if(j==T.length)v=i-T.length;elsev=-1;return v;}/*求模式串next[j]值的操作 */void GetNext(String T, int next[])/*求子串T的next[j]值并存放于数组next中*/ {int j=1, k=0;next[0]=-1;next[1]=0;while(j<T.length){if(T.str[j]=T.str[k]){next[j+1]=k+1;j++;k++;}else if(k==0){next[j+1]=0;j++;}else k=next[k];}}/*查找子串BF(Brute-Force)算法累计次数 */int BFIndexC(String S, int start, String T)/*查找主串S从start开始的子串T,找到返回T在S中的开始字符下标,否则返回-1*/{int i= start, j=0, t=0;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else{i=i-j+1;j=0;}t++;}return t;}/*查找子串KMP(D.E.Knuth-J.H.Morris-V.R.Pratt)操作 */ int KMPIndexC(String S, int start, String T, int next[])/*查找主串S从start开始的子串T,找到返回T在S中的首字符下标,*/ /*否则返回-1*//*数组Next中存放有模式串T的next[j]值*/{int i= start, j=0, t=0;while(i<S.length && j<T.length){if(S.str[i]==T.str[j]){i++;j++;}else if(j==0)i++;else j=next[j];t++;}return t;}测试主函数:#include<stdio.h>#define MaxSize 100#include"SString.h"#include"BFandKMP.h"void main(void){String S={{"cddcdc"},6}, T={{"abcde"},5};String S1={{"aaaaaaaa"},8}, T1={{"aaaab"},5};String S2={{"aaaaaaaaaaaaaaaaad"},18}, T2={{"aaaab"},5};int next[20], count;count=BFIndexC(S,0,T);printf("从S中查找T的Brute-Force算法比较次数:%d\n",count); GetNext(T, next);count=KMPIndexC(S,0,T,next);printf("从S中查找T的KMP算法比较次数:%d\n",count);count=BFIndexC(S1,0,T1);printf("从S1中查找T1的Brute-Force算法比较次数:%d\n",count); GetNext(T1, next);count=KMPIndexC(S1,0,T1,next);printf("从S1中查找T1的KMP算法比较次数:%d\n",count);count=BFIndexC(S2,0,T2);printf("从S2中查找T2的Brute-Force算法比较次数:%d\n",count); GetNext(T2, next);count=KMPIndexC(S2,0,T2,next);printf("从S2中查找T2的KMP算法比较次数:%d\n",count);}4-20的部分代码:Replace函数:/* 从主串S中查找字串T,若存在,并用串V替换串T并返回1,否则,返回0*/ int Replace(String S,int start,String T,String V){int i,v;Initiate(&S);Initiate(&T);Initiate(&V);for(i=0; i<strlen(S.str); i++)S.length=S.length+1;for(i=0; i<strlen(T.str); i++)T.length=T.length+1;for(i=0; i<strlen(V.str); i++)V.length=V.length+1;i=BFIndex(S, 0, T);if (i!=-1){if(Delete(&S, i, T.length))Insert(&S, i, V);for(i=0; i<S.length; i++)printf("%c", S.str[i]);printf("\n");return v=1;}else{printf("主串S中不存在串T\n");return v=0;}}测试主函数:#define MaxSize 80#include<stdio.h>#include<string.h>#include "SString.h"int main(void){ int v;String S={"I am a student."}, T={"student"}, V={"teacher"}; v=Replace(S,0,T,V);printf("返回%d\n",v);}实验结果:4-19.程序调式结果:4-20.程序调式结果:总结与思考KMP算法的比较次数比Brute-Force算法的少。
数据结构——串实践报告
课程名称:数据结构实践课实验项目:定长串存储方法姓名:专业:班级:学号:计算机科学与技术学院实验教学中心2017 年9 月23 日实验项目名称:串的定长存储表示方法一、实践目的:1. 熟练掌握串的定长顺序存储表示方法。
2. 利用串的基本操作实现相关算法。
二、实践内容:1. 实现串的定长顺序存储表示的基本操作。
并用主程序进行多次验证。
2. 设s='abcdefghijk'、t='cde'为两个字符串,利用定长顺序存储结构的串操作,判断t是否为s的子串。
如果是,输出子串所在位置(第一个字符)。
编程实现。
3. 已知三个字符串分别为s=’ababababcaabcbcaaaaaa’,s1=’caab’, s2=’bcb’。
利用所学字符串基本运算的函数得到结果串为:s3=’caabcbcaaaaaacaaaaaa’。
编程实现。
三、实验用设备仪器及材料计算机四、实验原理及接线五、实验操作步骤// main4-1.cpp 检验bo4-1.cpp的主程序// c1.h (程序名)#include<string.h>#include<ctype.h>#include<malloc.h> // malloc()等#include<limits.h> // INT_MAX等#include<stdio.h> // EOF(=^Z或F6),NULL#include<stdlib.h> // atoi()#include<io.h> // eof()#include<math.h> // floor(),ceil(),abs()#include<process.h> // exit()// #include<iostream.h> // cout,cin// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE// c4-1.h 串的定长顺序存储表示#define MAXSTRLEN 30 // 用户可在255以内定义最大串长(1个字节)typedef char SString[MAXSTRLEN+1]; // 0号单元存放串的长度// bo4-1.cpp 串采用定长顺序存储结构(由c4-1.h定义)的基本操作(14个)// SString是数组,故不需引用类型。
数据结构实验报告《三、串及其应用》
数据结构实验报告《三、串及其应用》时间:20XX年X月X日数据结构实验报告- - - - 串及其应用之文学研究助手【问题描述】文学研究人员需要统计某篇英文小说中某些单词(特别是形容词)的出现次数和位置,甚至连数字和标点符号的个数也可以统计。
试写一个实现这一目标的文字统计系统,称为“文学研究助手”。
【基本要求】1、输入一页文字,静态存储一页文章,每行最多不超过80个字符,共N行;2、分别统计出其中英文字母数、空格数、标点符号及整篇文章总字数;3、统计某一字符串在文章中出现的次数,并输出该次数;4、删除某一子串,并将后面的字符前移。
【运用拓展】1、保存输入文章到本地text文本中;2、模式匹配基于KMP算法;3、仿真友好界面显示:(1)、要求用菜单选择操作,分别用几个子函数实现相应的功能;(2)、输入数据的形式和范围:可以输入大写、小写的英文字母、任何数字及标点符号。
(3)、输出形式:1)、分行输出用户输入的各行字符;2)、分5行输出“全部字母数“、“数字个数“、“空格个数“、“标点符号个数”“文章总字数“;3)、输出删除某一字符串后的文章。
【涉及的知识点】链串的插入,删除,查找,模式匹配(knp算法)及文件的写入与写出,用switch,case语句进行菜单的选择,用while 语句进行循环,用if语句进行条件的判断等等。
【设计思路】、总体思路:本文采用链式存储字符串,链串的插入采用后插法,以‘#’ 为字符串结束的标志。
在插入字符串的同时用文件存储字符串。
、删除算法的基本思路:输入要删除的字符串,同样以‘#’结束,然后在文中查找该字符串,若找到了则把它删除,同时长度要减少;否则,没找到不能删除。
查找算法与删除算法类似;但也有不同之处,不同在于:这里是要查找某字符串在文中出现的次数,因此,当找到该字符串后还要继续往后查找,并将次数加1;直到文章的末尾才结束查找。
、用菜单做选择:用switch,case语句进行选择判断,并用类的对象调用类的成员函数以实现特定的功能。
串的存储实验报告(3篇)
第1篇一、实验目的1. 理解串的概念及其在计算机中的应用。
2. 掌握串的存储方式及其在C语言中的实现。
3. 熟悉串的基本操作,如串的创建、串的复制、串的连接等。
4. 通过实验验证串操作的准确性和效率。
二、实验原理1. 串(String)是由零个或多个字符组成的有限序列,是计算机中常用的非数值数据类型。
2. 串的存储方式主要有两种:顺序存储和链式存储。
3. 顺序存储是将串的字符序列存储在一段连续的内存空间中,通过数组来实现。
4. 链式存储则是通过链表来实现,每个节点存储一个字符,节点之间通过指针连接。
三、实验环境1. 操作系统:Windows 102. 编程语言:C3. 编译器:Visual Studio 2019四、实验内容1. 创建一个串,并对其进行初始化。
2. 复制一个串,并验证复制的串与原串内容相同。
3. 连接两个串,并验证连接后的串内容。
4. 实现串的插入、删除、查找等操作。
5. 对串进行排序,如按字典序排序。
五、实验步骤1. 创建一个串```cinclude <stdio.h>include <stdlib.h>include <string.h>define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int length;} String;// 创建串String createString(const char str) { String s;strcpy(s.data, str);s.length = strlen(str);return s;}```2. 复制一个串```c// 复制串String copyString(const String s) { String t;strcpy(t.data, s.data);t.length = s.length;return t;}```3. 连接两个串```c// 连接两个串String concatString(const String s1, const String s2) { String s;strcpy(s.data, s1.data);strcat(s.data, s2.data);s.length = s1.length + s2.length;return s;}```4. 实现串的插入、删除、查找等操作```c// 插入字符void insertChar(String s, int pos, char ch) {if (pos < 0 || pos > s->length) {printf("Insert position is invalid.\n");return;}for (int i = s->length; i >= pos; i--) {s->data[i + 1] = s->data[i];}s->data[pos] = ch;s->length++;}// 删除字符void deleteChar(String s, int pos) {if (pos < 0 || pos >= s->length) {printf("Delete position is invalid.\n"); return;}for (int i = pos; i < s->length - 1; i++) { s->data[i] = s->data[i + 1];}s->length--;}// 查找字符int findChar(const String s, char ch) {for (int i = 0; i < s.length; i++) {if (s.data[i] == ch) {return i;}}return -1;}```5. 对串进行排序```c// 字典序排序void sortString(String s) {for (int i = 0; i < s->length - 1; i++) {for (int j = i + 1; j < s->length; j++) {if (s->data[i] > s->data[j]) {char temp = s->data[i];s->data[i] = s->data[j];s->data[j] = temp;}}}}```六、实验结果与分析1. 创建串、复制串、连接串等操作均能正常进行,验证了串的存储和操作的正确性。
数据结构顺序串和链串实验报告
《数据结构》课程实验报告实验名称顺序串和链串实验序号 4 实验日期姓名院系班级学号专业指导教师成绩教师评语一、实验目的和要求(1)理解串和一般线形表之间的差异(2)重点掌握在顺序串上和链串上实现串的基本运算算法(3)掌握串的简单匹配算法和KMP算法(4)灵活运用串这种数据结构解决一些综合应用问题二、实验项目摘要编写一个程序algo4-1.cpp,实现顺序串的各种基本运算,并在此基础上设计一个主程序并完成如下功能:(1)建立串s=”abcdefghefghijklmn”和串sl=”xyz”;(2)输出串s;(3)输出串s的长度;(4)在串s的第9个字符位置插入串sl而产生串s2;(5)输出串s2;(6)删除串s的第2个字符开始的5个字符而产生的串s2;(7)输出串s2;(8)将串s的第2个字符开始的5个字符替换成串s1而产生串s2;(9)输出串s2;(10)提取串s的第2个字符开始的10个字符而产生串s3;(11)输出串s3;(12)将串s1和串s2连接起来而产生串s4;(13)输出串s4。
编写一个程序algo4-2.cpp,实现链串的各种基本运算,并在此基础上设计一个主程序并完成如下功能:(1)建立串s=”abcdefghefghijklmn”和串sl=”xyz”;(2)输出串s;(3)输出串s的长度;(4)在串s的第9个字符位置插入串sl而产生串s2;(5)输出串s2;(6)删除串s的第2个字符开始的5个字符而产生的串s2;(7)输出串s2;(8)将串s的第2个字符开始的5个字符替换成串s1而产生串s2;(9)输出串s2;(10)提取串s的第2个字符开始的10个字符而产生串s3;(11)输出串s3;(12)将串s1和串s2连接起来而产生串s4;(13)输出串s4。
三、实验预习内容顺序串的基本运算的算法(StrAssign(s,cstr),StrCopy(s,t),StrEquat(s,t),StrLength(s),Concat(s,t),SubStr (s,i,j),InsStr(s1,i,s2),DelStr(s,i,j),RepStr(s,i,j,t),DispStr(s))链串的基本运算的算法(StrAssign(s,cstr),StrCopy(s,t),StrEquat(s,t),StrLength(s),Concat(s,t),SubStr (s,i,j),InsStr(s1,i,s2),DelStr(s,i,j),RepStr(s,i,j,t),DispStr(s))三、实验结果与分析4-1#include <stdio.h>#define MaxSize 100typedef struct{ char data[MaxSize];int length;} SqString;void StrAssign(SqString &s,char cstr[]){ int i;for (i=0;cstr[i]!='\0';i++)s.data[i]=cstr[i];s.length=i;}void StrCopy(SqString &s,SqString t){ int i;for (i=0;i<t.length;i++)s.data[i]=t.data[i];s.length=t.length;}int StrEqual(SqString s,SqString t){ int same=1,i;if (s.length!=t.length)elsefor (i=0;i<s.length;i++)if (s.data[i]!=t.data[i]){ same=0;break;}return same;}int StrLength(SqString s){return s.length;}SqString Concat(SqString s,SqString t){ SqString str;int i;str.length=s.length+t.length;for (i=0;i<s.length;i++)str.data[i]=s.data[i];for (i=0;i<t.length;i++)str.data[s.length+i]=t.data[i];return str;}SqString SubStr(SqString s,int i,int j){ SqString str;int k;str.length=0;if (i<=0 || i>s.length || j<0 || i+j-1>s.length) return str;for (k=i-1;k<i+j-1;k++)str.data[k-i+1]=s.data[k];str.length=j;return str;}SqString InsStr(SqString s1,int i,SqString s2) { int j;SqString str;str.length=0;if (i<=0 || i>s1.length+1)for (j=0;j<i-1;j++)str.data[j]=s1.data[j];for (j=0;j<s2.length;j++)str.data[i+j-1]=s2.data[j];for (j=i-1;j<s1.length;j++)str.data[s2.length+j]=s1.data[j];str.length=s1.length+s2.length;return str;}SqString DelStr(SqString s,int i,int j){ int k;SqString str;str.length=0;if (i<=0 || i>s.length || i+j>s.length+1)return str;for (k=0;k<i-1;k++)str.data[k]=s.data[k];for (k=i+j-1;k<s.length;k++)str.data[k-j]=s.data[k];str.length=s.length-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t) { int k;SqString str;str.length=0;if (i<=0 || i>s.length || i+j-1>s.length)return str;for (k=0;k<i-1;k++)str.data[k]=s.data[k];for (k=0;k<t.length;k++)str.data[i+k-1]=t.data[k];for (k=i+j-1;k<s.length;k++)str.data[t.length+k-j]=s.data[k];str.length=s.length-j+t.length;return str;}void DispStr(SqString s){ int i;if (s.length>0){for (i=0;i<s.length;i++)printf("%c",s.data[i]);printf("\n");}}int main(){SqString s,s1,s2,s3,s4;printf("建立串s='abcdefghefghijklmn'和串sl='xyz'\n");StrAssign(s,"abcdefghefghijklmn");StrAssign(s1,"xyz");printf("输出串s:");DispStr(s);printf("串s的长度:%d\n",StrLength(s));printf("在串s的第9个字符位置插入串sl而产生串s2\n");s2=InsStr(s,9,s1);printf("输出串s2:");DispStr(s2);printf("删除串s的第2个字符开始的5个字符而产生的串s2\n");s2=DelStr(s,2,5);printf("输出串s2:");DispStr(s2);printf("将串s的第2个字符开始的5个字符替换成串s1而产生串s2\n"); s2=RepStr(s,2,5,s1);printf("输出串s2:");DispStr(s2);printf("提取串s的第2个字符开始的10个字符而产生串s3\n");s3=SubStr(s,2,10);printf("输出串s3:");DispStr(s3);printf("将串s1和串s2连接起来而产生串s4\n");s4=Concat(s1,s2);printf("输出串s4:");DispStr(s4);}4-2#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char cstr[]){ int i;LiString *r,*p;s=(LiString * )malloc(sizeof(LiString));r=s;for (i=0;cstr[i]!='\0';i++){ p=(LiString * )malloc(sizeof(LiString));p->data=cstr[i];r->next=p;r=p;}r->next=NULL;}void StrCopy(LiString *&s,LiString *t){ LiString * p=t->next,*q,*r;s=(LiString * )malloc(sizeof(LiString));r=s;while (p!=NULL){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;}int StrEqual(LiString *s,LiString *t){ LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data) { p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){ int i=0;LiString *p=s->next;while (p!=NULL){ i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){ LiString *str,*p=s->next,*q,*r;str=(LiString * )malloc(sizeof(LiString));r=str;while (p!=NULL){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;return str;}LiString *SubStr(LiString *s,int i,int j){ int k;LiString *str,*p=s->next,*q,*r;str=(LiString * )malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) return str;for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;return str;}LiString *InsStr(LiString *s,int i,LiString *t) { int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString * )malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1)return str;for (k=1;k<i;k++){ q=(LiString * )malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}while (p1!=NULL){ q=(LiString * )malloc(sizeof(LiString));q->data=p1->data;r->next=q;r=q;p1=p1->next;}while (p!=NULL){q=(LiString *)malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;return str;}LiString *DelStr(LiString *s,int i,int j){ int k;LiString *str,*p=s->next,*q,*r;str=(LiString * )malloc(sizeof(LiString));r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) return str;for (k=0;k<i-1;k++){ q=(LiString *)malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++)p=p->next;while (p!=NULL){q=(LiString *)malloc(sizeof(LiString));q->data=p->data;r->next=q;r=q;p=p->next;}r->next=NULL;return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) return str;for (k=0;k<i-1;k++){q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++)p=p->next;while (p1!=NULL){q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL){q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){ LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int main(){LiString *s,*s1,*s2,*s3,*s4;printf("建立串s和串s1\n");StrAssign(s,"abcdefghefghijklmn");StrAssign(s1,"xyz");printf("输出串s:");DispStr(s);printf("串s的长度:%d\n",StrLength(s));printf("在串s的第9个字符位置插入串s1而产生串s2\n");s2=InsStr(s,9,s1);printf("输出串s2:");DispStr(s2);printf("删除串s第2个字符开始的5个字符而产生串s2\n");s2=DelStr(s,2,3);printf("输出串s2:");DispStr(s2);printf("将串s第2个字符开始的5个字符替换成串s1而产生串s2\n");s2=RepStr(s,2,5,s1);printf("输出串s2:");DispStr(s2);printf("提取串s的第2个字符开始的10个字符而产生串s3\n");s3=SubStr(s,2,10);printf("(输出串s3:");DispStr(s3);printf("将串s1和串s2连接起来而产生串s4\n");s4=Concat(s1,s2);printf("输出串s4:");DispStr(s4);}注:空间不够,可以增加页码。
数据结构串的实验报告
一、实验目的1. 理解串的定义、性质和操作;2. 掌握串的基本操作,如串的创建、复制、连接、求子串、求逆序、求长度等;3. 熟练运用串的常用算法,如串的模式匹配算法(如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算法的编写和调试,但在老师和同学的指导下,我成功地解决了这些问题。
串-数据结构实验报告[修改版]
第一篇:串-数据结构实验报告【源程序】:#include #include #include void choose(char *s, int i,int m,char *t);//i位置截取m个字符函数void main() //主函数{ char *s,*t; int i,sl,m;s=(char *)malloc(100*sizeof(char));t=(char *)malloc(100*sizeof(char));printf("\n 输入主字符串s=?"); gets(s); printf("\n s=%s\n",s);printf("\n 输入位置i=?"); scanf("%d",&i); printf("\n i=%d\n",i);printf("\n 输入字符个数m=?"); scanf("%d",&m); printf("\n m=%d\n",m);sl=strlen(s);if(i>sl) printf("i位置出错\n");else if(i+m>sl+1) printf("m位置出错\n");else{choose(s,i,m,t);printf("\n 子串为t=%s\n",t);} } //end_main void choose(char *s, int i,int m,char *t) { int n;int j=0; for(n=i;n三.实验结论及分析串的存储结构包含有顺序存储结构和链式存储结构。
在串的顺序存储结构中,表示串的长度通常有两种方法:一种方法是设置一个串的长度参数,其优点在于便于在算法中用长度参数控制循环过程;另一种方法是在串值得末尾添加结束标记,此种方法的优点在于便于系统自动实现。
数据结构串的基本操作及应用实验报告(常用版)
数据结构串的基本操作及应用实验报告(常用版)(可以直接使用,可编辑完整版资料,欢迎下载)实验日期2021.5.10 教师签字成绩实验报告【实验名称】第四章串的基本操作及应用【实验目的】1、熟悉将算法转换成程序代码的过程。
2、了解串的逻辑结构特性,熟练掌握串顺序存储结构的C 语言描述方法。
3、熟练掌握串的基本操作:求长度、串的连接、插入、删除等,掌握串的存取特性。
【实验原理】1.串可以可以有三种存储方式,分别为顺序存储、堆分配存储、链式存储,串的基本操作在这三种存储方式下操作。
2.串的模式匹配KMP算法在每一趟匹配过程中出现字符不等时,不需回溯指针,而是利用已经得到的部分匹配结果的结果将模式向右滑动尽可能远的一段距离,继续进行比较。
【实验内容】1.串的顺序存储表示及基本操作(插入、删除、求串长、合并连接串、求子串、串比较等)#include<stdio.h>#include<iostream.h>#include<malloc.h>#include<string.h>#define SIZE 20struct HString{char ch[SIZE];int length;};void StrInsert(HString &s,int pos,HString t){int i,j;if(pos<1||pos>s.length+1)cout<<"ERROR!";if(t.length){for(i=s.length-1;i>=pos-1;--i)s.ch[i+t.length]=s.ch[i];for(j=0;j<=t.length-1;j++)s.ch[pos-1+j]=t.ch[j];s.length+=t.length;}}void StrDelete(HString &s,int pos,int len){int i;int v=pos-1;if(pos<1||pos>s.length||len<0||len>s.length-pos+1)cout<<"ERROR!";for(i=pos+len-1;i<=s.length-1;i++)s.ch[v++]=s.ch[i];s.length-=len;}void StrAssign(HString &t,char chars[]){int i;char *c;for(i=0,c=chars;*c;++i,++c);if(!i){t.length=0;}else{for(int j=0;j<i;j++)t.ch[j]=chars[j];t.length=i;}}int StrLen(HString &s){return s.length;}int StrCompare(HString &s,HString t){for(int i=0;i<s.length&&i<t.length;i++){if(s.ch[i]!=t.ch[i])return (int)(t.ch[i]-s.ch[i]);}return s.length-t.length;}void Concat(HString &t,HString s1,HString s2){int i=s1.length+s2.length;for(i=0;i<s1.length;i++)t.ch[i]=s1.ch[i];t.length=s1.length+s2.length;for(i=s1.length;i<t.length;i++)t.ch[i]=s2.ch[i-s1.length];}int SubString(HString &sub,HString s,int pos,int len) {if(pos<1||pos>s.length||len<0||len>s.length-pos+1) {cout<<"ERROR!"<<endl;return 0;}if(!len){sub.length=0;}else{int i=len;for(i=0;i<len;i++)sub.ch[i]=s.ch[pos+i-1];sub.length=len;}}void Display(HString &t){for(int i=0;i<=t.length-1;i++)cout<<t.ch[i];cout<<endl;}void main(){int i;char s[20];do{cout<<"选择您要进行的串的基本操作:"<<endl;cout<<"1.插入"<<endl<<"2.删除"<<endl<<"3.串连结"<<endl<<"4.取子串"<<endl<<"5.串比较"<<endl<<"6.求串长"<<endl<<"7.结束"<<endl;cin>>i;switch(i){case 1:{HString s,t;int pos;cout<<"请输入串s:";cin>>s.ch;StrAssign(s,s.ch);cout<<endl;cout<<"请输入要插入的串t:";cin>>t.ch;StrAssign(t,t.ch);cout<<endl;cout<<"请输入你所要插入的位置:";cin>>pos;StrInsert(s,pos,t);cout<<"插入之后串变为:";Display(s);break;}case 2:{HString s;int pos,len;cout<<"请输入串s:";cin>>s.ch;StrAssign(s,s.ch);cout<<"请输入你所要删除串的首位置为:";cin>>pos;cout<<"请输入你需要删除的串的长度:";cin>>len;StrDelete(s,pos,len);cout<<"删除之后串变为:";Display(s);break;}case 3:{HString s1,s2,t;cout<<"请输入串s1:";cin>>s1.ch;StrAssign(s1,s1.ch);cout<<"请输入串s2:";cin>>s2.ch;StrAssign(s2,s2.ch);Concat(t,s1,s2);cout<<"s1与s2合并后的串为:";Display(t);break;}case 4:{HString sub,s;int pos,len;cout<<"请输入主串s:";cin>>s.ch;StrAssign(s,s.ch);cout<<"请输入所取原串的起始位置pos:";cin>>pos;cout<<"请输入子串的长度len:";cin>>len;SubString(sub,s,pos,len);cout<<"取出的子串为:";Display(sub);break;}case 5:{HString s,t;int value;cout<<"请输入串s:";cin>>s.ch;StrAssign(s,s.ch);cout<<"请输入串t:";cin>>t.ch;StrAssign(t,t.ch);value=StrCompare(s,t);if(value>0) cout<<"串s大于串t"<<endl;else if(value==0) cout<<"串s等于串t"<<endl;else cout<<"串s小于串t"<<endl;cout<<endl;break;}case 6:HString s;char *chars;int val;cout<<"请输入串s:";cin>>s.ch;StrAssign(s,s.ch);val=StrLen(s);cout<<"串的长度为:"<<val<<endl;break;case 7:cout<<"操作结束!"<<endl;break;default:cout<<"输入错误!请重新输入!"<<endl;break;}}while(i!=7);}2.串的堆分配存储表示及基本操作(插入、删除、求串长、合并连接串、求子串、串比较等)#include<stdio.h>#include<iostream.h>#include<malloc.h>#include<string.h>struct HString{char *ch;int length;};void StrInsert(HString &s,int pos,HString t){int i,j;if(pos<1||pos>s.length+1)cout<<"ERROR!";if(t.length){s.ch=(char*)realloc(s.ch,(s.length+t.length)*sizeof(char));for(i=s.length-1;i>=pos-1;--i)s.ch[i+t.length]=s.ch[i];for(j=0;j<=t.length-1;j++)s.ch[pos-1+j]=t.ch[j];s.length+=t.length;}}void StrDelete(HString &s,int pos,int len){int i;int v=pos-1;if(pos<1||pos>s.length||len<0||len>s.length-pos+1)cout<<"ERROR!";for(i=pos+len-1;i<=s.length-1;i++)s.ch[v++]=s.ch[i];s.length-=len;}void StrAssign(HString &t,char *chars){int i;char *c;for(i=0,c=chars;*c;++i,++c);if(!i){t.ch=NULL;t.length=0;}else{t.ch=(char *)malloc(i*sizeof(char));for(int j=0;j<i;j++)t.ch[j]=chars[j];t.length=i;}}int StrLen(HString &s){return s.length;}int StrCompare(HString &s,HString t){for(int i=0;i<s.length&&i<t.length;i++){if(s.ch[i]!=t.ch[i])return (int)(t.ch[i]-s.ch[i]);}return s.length-t.length;}void Concat(HString &t,HString s1,HString s2){int i=s1.length+s2.length;t.ch=(char *)malloc(i*sizeof(char));for(i=0;i<s1.length;i++)t.ch[i]=s1.ch[i];t.length=s1.length+s2.length;for(i=s1.length;i<t.length;i++)t.ch[i]=s2.ch[i-s1.length];}int SubString(HString &sub,HString s,int pos,int len){if(pos<1||pos>s.length||len<0||len>s.length-pos+1){cout<<"ERROR!"<<endl;return 0;}if(!len){sub.ch=NULL;sub.length=0;}else{int i=len;sub.ch=(char *)malloc(i*sizeof(char));for(i=0;i<len;i++)sub.ch[i]=s.ch[pos+i-1];sub.length=len;}}void Display(HString &t){for(int i=0;i<=t.length-1;i++)cout<<t.ch[i];cout<<endl;}void main(){int i;char s[20];cout<<"选择您要进行的串的基本操作:"<<endl;do{cout<<"1.插入"<<endl<<"2.删除"<<endl<<"3.串连结"<<endl<<"4.取子串"<<endl<<"5.串比较"<<endl<<"6.求串长"<<endl<<"7.结束"<<endl;cin>>i;switch(i){case 1:{HString s,t;char a[20],b[20];char *sa,*sb;int pos;cout<<"请输入串s:";cin>>a;sa=a;StrAssign(s,sa);cout<<endl;cout<<"请输入要插入的串t:";cin>>b;sb=b;StrAssign(t,sb);cout<<endl;cout<<"请输入你所要插入的位置:";cin>>pos;StrInsert(s,pos,t);cout<<"插入之后串变为:";Display(s);break;}case 2:{HString s;char str[20];char *chars;int pos,len;cout<<"请输入串s:";cin>>str;chars=str;StrAssign(s,chars);cout<<"请输入你所要删除串的首位置为:";cin>>pos;cout<<endl;cout<<"请输入你需要删除的串的长度:";cin>>len;cout<<endl;StrDelete(s,pos,len);cout<<"删除之后串变为:";Display(s);break;}case 3:{char a[20],b[20];char *sa,*sb;cout<<"请输入串s1:";cin>>a;sa=a;StrAssign(s1,sa);cout<<"请输入串s2:";cin>>b;sb=b;StrAssign(s2,sb);Concat(t,s1,s2);cout<<"s1与s2合并后:";Display(t);break;}case 4:{HString sub,s;char a[20];char *sa;int pos,len;cout<<"请输入主串s:";cin>>a;sa=a;StrAssign(s,sa);cout<<"请输入所取原串的起始位置pos:";cin>>pos;cout<<"请输入子串的长度len:";cin>>len;SubString(sub,s,pos,len);cout<<"该子串为:";Display(sub);break;}case 5:{HString s,t;int value;char a[20],b[20];char *sa,*sb;cout<<"请输入串s:";cin>>a;sa=a;cout<<"请输入串t:";cin>>b;sb=b;StrAssign(t,sb);value=StrCompare(s,t);if(value>0) cout<<"串s大于串t"<<endl;else if(value==0) cout<<"串s等于串t"<<endl;else cout<<"串s小于串t"<<endl;cout<<endl;break;}case 6:HString s;char str[20];char *chars;int val;cout<<"请输入串s:";cin>>str;chars=str;StrAssign(s,chars);val=StrLen(s);cout<<"串的长度为:"<<val<<endl;break;case 7:cout<<"操作结束!"<<endl;break;default:cout<<"输入错误!请重新输入!"<<endl;break;}}while(i!=7);3.KMP算法的C实现#include<iostream.h>#include<malloc.h>#include<string.h>struct HString{char *ch;int length;};void StrAssign(HString &t,char *chars){int i;char *c;for(i=0,c=chars;*c;++i,++c);if(!i){t.ch=NULL;t.length=0;}else{t.ch=(char *)malloc(i*sizeof(char));for(int j=0;j<i;j++)t.ch[j]=chars[j];t.length=i;}}void get_next(HString s,int next[]){int i,j;i=1;j=0;next[1]=0;while(i<s.length){if(j==0||s.ch[i-1]==s.ch[j-1]){i++;j++;next[i]=j;}else j=next[j];}for(i=1;next[i]!='\0';i++)cout<<next[i]<<" ";}int Index(HString s,HString t,int pos){int i=pos;int j=1;int next[20];get_next(t,next);while(i<=s.length&&j<=t.length){if(s.ch[i-1]==t.ch[j-1]||j==0){ ++i;++j;}else{j=next[j];}}if(j>t.length)return i-t.length;else return 0;}void Display(HString t){for(int i=0;i<t.length;i++)cout<<t.ch[i];cout<<endl;}void main(){ HString s,t;int pos,k;char a[20],b[20];char *sa,*sb;cout<<"请输入主串s:";cin>>a;sa=a;StrAssign(s,sa);cout<<"请输入模式串t:";cin>>b;sb=b;StrAssign(t,sb);cout<<"请输入起始位置pos:";cin>>pos;k=Index(s,t,pos);if(k==0)cout<<"匹配失败!"<<endl<<endl;else{cout<<"从第"<<k<<"个位置开始匹配"<<endl;Display(s);for(int i=1;i<k;i++)cout<<" ";Display(t);}}【小结讨论】1. 此程序关键在于位置查询,由于对C语言函数的陌生导致问题变的繁琐,自己的C语言水平有待提高。
实验三 串
实验三 串一、实验目的通过训练,加深理解并把握串的基本运算的特点。
二、链接串设计本题目中的串编辑要求对串实现以下两种功能:⑴插入:把一个字符串插入到给定串的指定位置;⑵删除:将串中某指定位置开始的若干字符从串中删除;【实现提示】⑴ 数据结构① 结点结构:一个结点由 DATA 和 LINK 两个字段组成,如下所示: DATALINK在 DATA 字段中存放一个字符② 字符串结构:用一个单循环链表表示一个字符串,如,T=‘ABCD’串可以由下 面的单链循环表来表示: T T 指向循环链表的表尾。
③插入或置换子串的结构:用一个单链表表示要插入的子串,tp 为头指阵,bn 为尾指针,如:tp bn⑵算法基本思想:算法开始时给出一个空串,用户可以在此基础上进行编辑。
a)插入·输入插入起始位置;·构造插入子串; ·实现插入 ;·打印输出插入后的子串。
b) 删除B C DA 12 3·输出删除起始位置和删除长度; ·实现删除;·打印输出删除后的字符串。
c)结束串编辑,终止编辑过程。
三、顺序串的常用操作1. 根据以下参考程序,完成未实现的方法;2. 用 C++ 标准库中的 string类,完成同样的功能。
【参考程序】#include <iostream>using namespace std;class String{public:String(){};~String(){};String SubString(int pos,int num);void Insert(String t,int pos);void Delete(int pos,int num);void Creat();void Display();private:char *str;int size;};//生成新字符串函数void String:: Creat(){//char *s=new char[20];char *s="xxxxxx";cin>>s;size=strlen(s);str=new char[size];if(str==0) cout<<"没有申请到空间!";strcpy(str,s);}//输出void String::Display(){ int i;for(i=0;i<size;i++) cout<<str[i];cout<<endl;}//求子串String String::SubString(int pos,int num){String r;return r;}//插入运算:在串对象s的pos位置后插入一个串tvoid String::Insert(String t,int pos){}//删除:删除串中的一个子串void String:: Delete(int pos,int num){}//主函数int main(int argc, char* argv[]){ int pos,num,k;String s,s1,t;do{ cout<<"\n\n 1.生成字符串" ;cout<<"\n\n 2.取子串";cout<<"\n\n 3.插入子串s1";cout<<"\n\n 4.删除子串";cout<<"\n\n 5.结束程序";cout<<"\n******************************** ";cout<<"\n 请输入你的选择(1,2,3,4,5)"; cin>>k;switch(k){case 1:{cout<<"请输入一个字符串:";s.Creat();cout<<"字符串为: "; s.Display();}break;case 2:{ cout<<"请输入子串的截取位置pos及子串长度num"<<endl;cin>>pos>>num;t=s.SubString(pos,num);cout<<"你所取的子串为: "; t.Display();}break;case 3:{ cout<<"请输入子串插入位置pos"<<endl;cin>>pos;cout<<"请输入要插入的子串: "; s1.Creat();s.Insert(s1,pos);cout<<"插入后的字符串为: "; s.Display();}break;case 4:{ cout<<"请输入要删除子串的开始位置pos及子串长度 num"<<endl;cin>>pos>>num;s.Delete(pos,num);cout<<"删除后的字符串为: ";s.Display();}break;default:break;} //switchcout<<"\n--------------------------------- ";}while(k>=1&&k<5);cout<<"\n 再见!";cout<<"\n 按任意键,返回。
数据结构串的应用及实现报告
实习报告课程名称: 数据结构实验名称: 串及其应用指导教师:学生班级:学生姓名:学生学号:完成日期:一、 需求分析1、本演示程序用C语言编写,实现串的堆分配存储基本操作、串的建立、串的输出、串的联接、求子串、串匹配、串的插入删除、串的替换等实现方法。
2、程序所达到的功能:(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是否相等,输出结果二、 概要设计1、编写栈的基本操作函数链串类型定义如下所示:typedef struct snode{char data;struct snode *next;}listring;(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)返回由两个串s和t连接在一起形成的新串。
(6)求子串 SubStr(s,i,j)返回串s中从第i(1≤i≤StrLength(s))个字符开始的、由连续j个字符组成的子串。
(7)插入InsStr (s,i,t)将串t插入到串s的第i(1≤i≤StrLength(s)+1)个字符中,即将t的第一个字符作为s的第i个字符,并返回产生的新串(8)串删除 DelStr (s,i,j)从串s中删去从第i(1≤i≤StrLength(s))个字符开始的长度为j的子串,并返回产生的新串。
数据结构实验报告三
<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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
//判断字符串是否为空
void empstr(listring *s){
if(s->next==NULL)
printf("字符串是空的!");
else
printf("字符串不为空!");
}
void initstr(listring *&s){
s=(listring *)malloc(sizeof(listring));
(8)串删除DelStr (s,i,j)
从串s中删去从第i(1≤i≤StrLength(s))个字符开始的长度为j的子串,并返回产生的新串。
(9)串替换RepStr (s,s1,s2)
在串s中,将所有出现的子串s1均替换成s2。
(10)输出串DispStr(s)
输出串s的所有元素值
(11)判断串是否为空IsEmpty(s)
返回由两个串s和t连接在一起形成的新串。
(6)求子串SubStr(s,i,j)
返回串s中从第i(1≤i≤StrLength(s))个字符开始的、由连续j个字符组成的子串。
(7)插入InsStr (s,i,t)
将串t插入到串s的第i(1≤i≤StrLength(s)+1)个字符中,即将t的第一个字符作为s的第i个字符,并返回产生的新串
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
while(p1!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p1->data;
q=(listring *)malloc(sizeof(listring));
q->data=p1->data;
r->next=q;
r=q;
p1=p1->next;
}
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
二、实验环境
装有Visual C++6.0的计算机。
三、实验内容
编写一个程序,实现链串的各种基本运算,并在此基础上设计一个主程序。具体如下:
编写栈的基本操作函数
链串类型定义如下所示:
typedef struct snode{
char data;
struct snode *next;
}listring;
strcopy(t1,t);
printf("输出t1的长度:%d\n",strlength(t1));
s2=insstr(s,9,s1);
printf("输出s2:\n");
dispstr(s2);
s3=delstr(s,2,5);
printf("输出s3:\n");
dispstr(s3);
s4=repstr(s,2,3,s1);
(6)提取串s的第8个字符开始的4个字符而产生串s5,并输出s5
(7)将串s1和串t连接起来而产生串s6,并输出s6
(8)比较串s1和s5是否相等,输出结果
程序清单:
#include<stdio.h>
#include<stdlib.h>
typedef struct snode{
char data;
struct snode *next;
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
r->next=NULL;
return str;
}
//字符串替换
listring *repstr(listring *s,int i,int j,listring *t){
str=(listring *)malloc(sizeof(listring));
str->next=NULL;
r=str;
if(i<=0||i>strlength(s)||j<0||i+j-1>strlength(s))
return str;
for(k=0;k<i-1;k++)
p=p->next;
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
r->next=NULL;
return str;
}
//字符串的子串
listring *substr(listring *s,int i,int j){
int k;
listring *str,*p=s->next,*q,*r;
r=str;
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
p=t->next;
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
listring *delstr(listring *s,int i,int j){
int k;
listring *str,*p=s->next,*q,*r;
str=(listring *)malloc(sizeof(listring));
str->next=NULL;
r=str;
if(i<=0||i>strlength(s)||j<0||i+j-1>strlength(s))
else
printf("s1与s5不相等!");
return 0;
}
运行结果:
四、实验心得与小结
这次上机的内容是实现链串的基本算法,跟前面学的链表的基本算法是差不多的,所以这次实验还是比较简单的,但也曾出现过一点点小问题,直接把字符串赋值给指针s="abcdefghijklmn";s1="xyz";t="hijk";结果出现如下错误:
int k;
listring *str,*p=s->next,*p1=t->next,*q,*r;
str=(listring *)malloc(sizeof(listring));
str->next=NULL;
r=str;
if(i<=0||i>strlength(s)||j<0||i+j-1>strlength(s))
r->next=q;
r=q;
p1=p1->next;
}
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
r->next=NULL;
return str;
}
//字符串删除
int k;
listring *str,*p=s->next,*p1=t->next,*q,*r;
str=(listring *)malloc(sizeof(listring));
str->next=NULL;
r=str;
if(i<=0||i>strlength(s)+1)
return str;
for(k=1;k<i;k++){
(1)串赋值Assign(s,t)
将一个字符串常量赋给串s,即生成一个其值等于t的串s
(2)串复制StrCopy(s,t)
将串t赋给串s
(3)计算串长度StrLength(s)
返回串s中字符个数
(4)判断串相等StrEqual(s,t)
若两个串s与t相等则返回1;否则返回0。
(5)串连接Concat(s,t)
return str;
for(k=0;k<i-1;k++){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
for(k=0;k<j;k++)
p=p->next;
while(p1!=NULL){
r=s;
while(p!=NULL){
q=(listring *)malloc(sizeof(listring));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
}
r->next=NULL;
}
//字符串长度
int strlength(listring *s){
int i=0;
listring *p=s->next;
while(p!=NULL){