串的基本操作

合集下载

数据结构串的基本操作及应用实验报告

数据结构串的基本操作及应用实验报告

实验日期2010.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:{HString s1,s2,t;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;StrAssign(s,sa);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语言水平有待提高。

第四章串的基本操作

第四章串的基本操作
return OK;
}
//算法4.5
//返回子串T在主串S中第pos个字符之后的位置,若不存在,则函数值为0
int Index(SString S,SString T,int pos)
{
int i,j;
if(1<=pos&&pos<=S[0])
{
i=pos;
j=1;
while(i<=S[0]&&j<=T[0])
串的基本操作:
程序代码:
#include<stdio.h>//注意,S[0]放长度,循环i从什么地方开始。
#include<stdlib.h>
#include<string.h>//串的定长顺序存储结构(基本操作13个),SString是数组,故不需引用类型
#define OK 1
#define ERROR 0
printf("串长超过MAX_STR_LEN(=%d)\n",MAX_STR_LEN);
exit (0);
}
printf("串长为%d串空否?%d(1:是0:否)\n",StrLength(S1),StrEmpty(S1));
StrCopy(S2,S1);
printf("拷贝S1生成的串为");
StrPrint(S1);
for(i=pos;i<pos+T[0];i++)
S[i]=T[i-pos+1];
S[0]+=T[0];
return TRUE;
}
else
{//部分插入
for(i=MAX_STR_LEN;i>=pos+T[0];i--)

串的基本操作范文

串的基本操作范文

串的基本操作范文串是一种常见且重要的数据结构,其由一个个字符组成的有序序列。

本文就串的基本操作进行详细介绍,包括串的定义、串的表示方法、串的操作等内容。

一、串的定义串是由零个或多个字符组成的有序序列,其中字符的数目称为串的长度。

串是一种线性结构,通常用于表示文本或字符串。

二、串的表示方法1. 静态数组表示:利用C/C++等编程语言中的字符数组来表示串。

例如,“Hello”可以表示为一个字符数组char str[6] = "Hello",其中str[0]='H',str[1]='e',依此类推。

2. 动态数组表示:利用动态内存分配来创建存储串的数组。

例如,在C++中可以使用string类来表示串。

3.链表表示:采用链表的方式来表示串,每个节点存储一个字符,并用指针链接起来。

三、串的基本操作串具有以下基本操作:1. 求串的长度:即求出串中字符的个数,常用的函数有strlen(,可以直接调用。

例如,strlen("Hello")将返回5,表示串的长度为52. 求子串:从串中截取一个子串。

常用的函数有substr(等。

例如,substr("Hello World", 6, 5)将返回"World",表示从原串中的第6个字符开始,截取长度为5的子串。

3. 拼接串:将两个串拼接起来得到一个新的串。

常用的函数有strcat(,可以直接调用。

例如,strcat("Hello", " World")将返回"Hello World",表示将第二个串拼接到第一个串的末尾。

4. 比较串:判断两个串是否相等。

常用的函数有strcmp(,可以直接调用。

例如,strcmp("Hello", "Hello")将返回0,表示两个串相等。

串的定义和基本运算(精)

串的定义和基本运算(精)
s1->str=(char*)malloc(sizoef(char));s1->str[0]=’\0’;s1>length=0;return ERROR;} s1->str=(char*)malloc((len+1)*sizeof(char)); if (!s1.str) return ERROR; s1->str[0..len-1]=s2.str[start-1..start+len -2]; s1->str[len]=’\0’; s1->length=len; return OK; }
int length;
}STRING; 不同的定义形式,算法中的处理也略有不同。下 面我们将给出在第二种顺序存储方式下串的几个基本 操作的算法。
(1) 串的赋值 int StringAssign(STRING*s,char *string_constant) { if (s->str) free(s->str);
2. 链式存储结构
由于串结构中每个数据元素为一个字符,所以最 直接的链式存储结构是每个结点的数据域存放一个字 符。举例:
S
s
t r i n g^
图 4-1
优点是操作方便;不足ቤተ መጻሕፍቲ ባይዱ处是存储密度较低。所 谓存储密度为:
串值所占的存储单元 存储密度
实际分配的存储密度
若要将多个字符存放在一个结点中,就可以缓解 这个问题。举例:
(4)串连接 int Concat(STRING *s1,STRING s2) { STRING s; StringAssign(&s,s1->str); //将s1原来的内容保留在s中 len=Length(s1)+Length(s2);

实现串的基本操作

实现串的基本操作

实现串的基本操作1. 什么是串?串是由零个或多个字符组成的有限序列。

它是计算机科学中非常重要的一个数据结构,在各种应用程序中广泛使用。

串可以包含任意类型的字符,比如字母、数字、符号等。

在实际编程中,我们通常使用字符串来表示和操作串。

2. 串的基本操作对于串的基本操作,主要包括以下几个方面:2.1. 初始化串初始化串即创建一个新的空串。

在很多编程语言中,可以使用特定的语法来初始化一个空串,比如在C语言中,可以使用char s[MAX_LEN] = ""来初始化一个空串。

在其他一些编程语言中,可以使用空串字面量来表示一个空串。

2.2. 求串的长度求串的长度是指得到一个串中字符的个数。

对于一个已知的串,我们可以通过遍历字符串并统计字符个数来求得它的长度。

在很多编程语言中,也提供了现成的函数或方法来直接获取串的长度。

2.3. 比较串比较串是指判断两个串是否相等。

在很多编程语言中,可以使用==运算符来比较两个串是否相等。

需要注意的是,在比较两个串时,通常要考虑区分大小写和字符编码等因素。

2.4. 复制串复制串即将一个串的内容复制到另一个串中。

在很多编程语言中,都提供了现成的函数或方法来实现串的复制操作。

2.5. 连接串连接串是指将两个或多个串拼接成一个新的串。

在很多编程语言中,可以使用特定的运算符或函数来实现字符串的连接操作。

3. 串的实现方式3.1. 顺序存储顺序存储是指将串的字符按照顺序存储在一片连续的存储空间中。

在顺序存储的方式下,我们可以通过数组来实现串的基本操作。

其中,数组的每个元素对应于串的每个字符。

3.2. 链式存储链式存储是指使用链表来存储串的字符。

在链式存储的方式下,每个节点包含一个字符和一个指向下一个节点的指针。

通过这种方式,可以方便地插入和删除字符。

4. 示例代码下面以C语言为例,给出一个简单的串的实现示例:#include <stdio.h>#include <stdlib.h>typedef struct Node {char data;struct Node* next;} Node;typedef struct {Node* head;int length;} String;// 初始化串void initString(String* string) {string->head = NULL;string->length = 0;}// 求串的长度int getLength(String string) {return string.length;}// 比较串int compareString(String string1, String string2) {Node* p = string1.head;Node* q = string2.head;while (p != NULL && q != NULL && p->data == q->data) { p = p->next;q = q->next;}if (p == NULL && q == NULL) {return 0;} else if (p == NULL) {return -1;} else if (q == NULL) {return 1;} else {return p->data - q->data;}}// 复制串void copyString(String* target, String source) {Node* p = source.head;target->head = NULL;target->length = 0;while (p != NULL) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = p->data;newNode->next = NULL;if (target->head == NULL) {target->head = newNode;} else {Node* q = target->head;while (q->next != NULL) {q = q->next;}q->next = newNode;}target->length++;p = p->next;}}// 连接串void concatString(String* target, String string1, String string2) { target->head = NULL;target->length = 0;Node* p = string1.head;while (p != NULL) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = p->data;newNode->next = NULL;if (target->head == NULL) {target->head = newNode;} else {Node* q = target->head;while (q->next != NULL) {q = q->next;}q->next = newNode;}target->length++;p = p->next;}p = string2.head;while (p != NULL) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = p->data;newNode->next = NULL;Node* q = target->head;while (q->next != NULL) {q = q->next;}q->next = newNode;target->length++;p = p->next;}}// 销毁串void destroyString(String* string) {Node* p = string->head;while (p != NULL) {Node* next = p->next;free(p);p = next;}string->head = NULL;string->length = 0;}int main() {String string1, string2, string3;initString(&string1);initString(&string2);initString(&string3);// 初始化串Node* node1 = (Node*)malloc(sizeof(Node));node1->data = 'H';node1->next = NULL;Node* node2 = (Node*)malloc(sizeof(Node));node2->data = 'e';node2->next = NULL;Node* node3 = (Node*)malloc(sizeof(Node));node3->data = 'l';node3->next = NULL;Node* node4 = (Node*)malloc(sizeof(Node));node4->data = 'l';node4->next = NULL;Node* node5 = (Node*)malloc(sizeof(Node));node5->data = 'o';node5->next = NULL;string1.head = node1;node1->next = node2;node2->next = node3;node3->next = node4;node4->next = node5;string1.length = 5;// 求串的长度int length = getLength(string1);printf("The length of the string is: %d\n", length);// 比较串initString(&string2);Node* node6 = (Node*)malloc(sizeof(Node));node6->data = 'H';node6->next = NULL;Node* node7 = (Node*)malloc(sizeof(Node));node7->data = 'e';node7->next = NULL;Node* node8 = (Node*)malloc(sizeof(Node));node8->data = 'l';node8->next = NULL;Node* node9 = (Node*)malloc(sizeof(Node));node9->data = 'l';node9->next = NULL;Node* node10 = (Node*)malloc(sizeof(Node));node10->data = 'o';node10->next = NULL;string2.head = node6;node6->next = node7;node7->next = node8;node8->next = node9;node9->next = node10;string2.length = 5;int result = compareString(string1, string2);if (result == 0) {printf("The two strings are equal.\n");} else if (result < 0) {printf("String1 is smaller than string2.\n"); } else {printf("String1 is larger than string2.\n"); }// 复制串copyString(&string3, string1);printf("The copied string is: ");Node* p = string3.head;while (p != NULL) {printf("%c", p->data);p = p->next;}printf("\n");// 连接串concatString(&string3, string1, string2);printf("The concatenated string is: ");p = string3.head;while (p != NULL) {printf("%c", p->data);p = p->next;}printf("\n");// 销毁串destroyString(&string1);destroyString(&string2);destroyString(&string3);return 0;}5. 总结串是计算机科学中重要的数据结构,用于表示和操作由字符组成的有限序列。

串的基本操作

串的基本操作

i 串的基本操作一、 实验目的、意义(1) 理解串的堆分配存储结构。

(2) 理解用它们表示时插入,生成串,联接串与求子串的算法。

(3) 根据具体问题的需要,能够设计出相关算法。

二、 实验内容及要求说明1:学生在上机实验时,需要自己设计出所涉及到的函数,同时设计多组输 入数据并编写主程序分别调用这些函数,调试程序并对相应的输出作出分析;修 改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

具体要求:定义串的堆分配存储,完成串的基本操作:插入,生成串,联接串,求子串三、实验所涉及的知识点C 语言算法、循环算法、串的堆分配存储结构、插入,生成串,联接 串与求子串的算法。

四、实验结果及分析(所输入的数据及相应的运行结果,运行结果要有提示信息,运行结果采用截图 方式给出。

)F 'E=∖JK^⅛t⅛iS^∖Deb ug∖T extl .e κe 1 n 呂扇: c-⊃S 》爭t-託联接串0产主的串片为:GOd bιje!God luck?:GOd bj/ef&串空否? «<1: X 肌否)GDd Inch?⅛s70 ≡ OO⅛⅛串t 相同的子串用串討弋普后.串晚:GQqd by^tGood Iucl<t晴空后,串长为0 S5? KI :空0:左■生-的第&个字槻的4个字符, :GoDd bye?GOOd IUCkT串占后,串七 除5个主犢后- t 和串酣;冃同 守起.⅛⅛s⅛同的第1GOOd byeTbyefGood luck? ⅛ ≡byef bspefGo Dd luck! i↑r ^衬串七述串L j ■串七 串t 的第1个号 4 FL ∣≡√⅛ : byet五、总结与体会i(调试程序的心得与体会,若实验课上未完成调试,要认真找出错误并分析原因等。

) 调试程序时,出现了许多错误。

如:串的堆分配存储结构、串的联接等。

另外还有一些语法上的错误。

由于对所学知识点概念模糊,试验课上未能完成此次上机作业。

串的基本操作

串的基本操作

实验七串的基本运算实验时间2011-4-19实验地点:机房2实验目的:(1)掌握串的特点及其顺序定长存储方式。

(2)掌握串的创建、连接、插入、删除、显示、查找、取子字符串、比较串的大小的操作(3)掌握模式匹配的思想和算法。

1、问题描述串是一种特殊的线性表,串中所有数据元素都按某种次序排列在一个序列中。

串是由0个或多个字符构成的有限序列。

线性表有两种存储结构:顺序存储和链式存储,串是一种特殊的线性表,因此也有两种基本存储结构:顺序串和链式串。

采用顺序存储时,串是用一块地址连续的存储单元来存储串值。

串链式存储时,链表中每个结点可以存放一个字符,也可以存放多个字符。

串的模式匹配即子串定位。

设s和t是给定的两个串,在主串s中找到子串t的过程称为模式匹配。

如果在主串s中找到子串t,则匹配成功,函数返回子串t在主串s中首次出现的存储(或序号);否则匹配不成功,返回-1。

2、数据结构设计串的数据类型:typedef struct{char vec[STRINGMAX]int len;}str;3、功能(函数)说明串的基本操作:void ConcatStr(str *r1,str *r2) //连接字符串void SubStr(str *r,int i,int j) //取出子字符串void DelStr(str *r,int i,int j) //删除子字符串str *InsStr(str *r,str *r1,int i) //插入子字符串int InDexStr(str *r,str *r1) //查找子字符串int LenStr(str *r) //计算字符串长度int EqualStr(str *r1,str *r2) //比较字符串大小4、界面设计指导用户按照正确的格式输入数据。

5、编码实现#include<stdio.h>#define STRINGMAX 100typedef struct{char vec[STRINGMAX];int len;void ConcatStr(str *r1, str *r2) //串连接{int i;printf("\n.t.tr1=%s r2=%\n ", r1->vec, r2->vec);if (r1->len+r2->len> STRINGMAX)// 连接后的串长超过串的最大长度printf("\n\t\t两个串太长,溢出!\n");else{for(i=0;i<r2->len;i++)r1->vec[r1->len+i]=r2->vec[i]; //进行连接r1->vec[r1->len+i]='\0';r1->len=r1->len+r2->len; //修改连接后新串的长度}}void SubStr(str *r,int i,int j)//求子串{int k;str a;str *r1=&a;if(i+j-1>r->len){printf("\n\t\t字串超界!\n");return;}else{for(k=0;k<j;k++)r1->vec[k]=r->vec[i+k-1]; //从r中取出子串r1->len=j;r1->vec[r->len]='0';}printf("\n\t\t取出字符为: ");puts (r1->vec);}void DelStr(str *r, int i, int j)//删除子串,i指定位置,j为连续删除的字符个数{int k;if(i+j-1>r->len)printf("\n\t\t所要删除的子串超界!\n");else{for(k=i+j;k<r->len;k++,i++)r->vec[i]=r->vec[k]; //将后面字符串前移覆盖r->len=r->len-j;r->vec[r->len]='\0';}str *InsStr(str *r,str *r1,int i){int k;if(i>=r->len || r->len+r1->len>STRINGMAX)printf("\n\t\t不能插入!\n");else{for(k=r->len-1;k>=i;k--)r->vec[r1->len+k]=r->vec[k]; //后移空出位置for(k=0;k<r1->len;k++)r->vec[i+k]=r1->vec[k]; //插入子串r1r->len=r->len+r1->len;r->vec[r->len]='\0';}return r;}int IndexStr(str *r, str *r1){int i,j,k;for(i=0;r->vec[i];i++)for(j=i,k=0;r->vec[j]==r1->vec[k];j++,k++)if(!r1->vec[k+1])return i;return -1;}int LenStr(str *r){int i=0;while(r->vec[i]!='\0')i++;return i;}str *CreateStr(str *r){gets(r->vec);r->len=LenStr(r);return r;}int EqualStr(str *r1,str *r2){for(int i=0;r1->vec[i]&&r2->vec[i]&&r1->vec[i]==r2->vec[i];i++); return r1->vec[i]-r2->vec[i];}void main(){str a,b,c,d;str *r=&a,*r1;r->vec[0]='\0';char choice, p;int i,j,ch=1;while(ch!=0){printf ("\n");printf("\n\t\t串的基本操作");printf("\n\t\t******************");printf("\n\t\t* 1-----输入字串*");printf("\n\t\ t* 2-----连接字串*");printf("\n\t\ t* 3-----取出字串*");printf("\n\t\ t* 4----删除字串*");printf("\n\t\ t* 5-----插入字串*");printf("\n\t\ t * 6-----查找字串*"); printf("\n\t\ t* 7-----比较串大小*"); printf("\n\t\ t* 8-----显示字串*"); printf("\n\t\ t* 0-----返回*"); printf("\n\t\ t**********************"); printf("\n\t\ t请选择菜单号(0-8): ");scanf ("%c", &choice);getchar();if(choice=='1'){printf("\n\t\ t请输入字符串:");gets(r->vec);r->len=LenStr(r);}else if(choice=='2'){printf("\n\t\ t请输入所要连接的串:");r1=CreateStr(&b);ConcatStr(r,r1);printf("\n\t\t连接以后的新串值为:");puts(r->vec);}else if(choice=='3'){printf("\n\t\ 请输入从第几个字符开始:");scanf("%d",&j);getchar();SubStr(r,i,j);}else if(choice=='4'){printf("\n\t\t 请输入从第几个字符开始:");scanf("%d",&i);getchar();printf("\n\t\t请输入删除的连续字符数:");scanf("%d",&j);getchar();DelStr(r,i-1,j);}else if(choice=='5'){printf("\n\t\t 请输入从第几个字符开始:");scanf ("%d",&i);getchar();printf("\n\t\t请输入所要插入的字符串:");r1=CreateStr(&b);InsStr(r,r1,i-1);}else if(choice=='6'){printf("\n\t\t请输入所要查找的字符串:");r1=CreateStr(&b);i=IndexStr(r,r1);if(i=-1)printf("\n\t\t第一次出现的位置是第%d个。

串的基本操作

串的基本操作

串得基本操作一、实验目得、意义(1)理解串得堆分配存储结构。

(2)理解用它们表示时插入,生成串,联接串与求子串得算法。

(3)根据具体问题得需要,能够设计出相关算法。

二、实验内容及要求说明1:学生在上机实验时,需要自己设计出所涉及到得函数,同时设计多组输入数据并编写主程序分别调用这些函数,调试程序并对相应得输出作出分析;修改输入数据,预期输出并验证输出得结果,加深对有关算法得理解。

具体要求:定义串得堆分配存储,完成串得基本操作:插入,生成串,联接串,求子串等。

三、实验所涉及得知识点C语言算法、循环算法、串得堆分配存储结构、插入,生成串,联接串与求子串得算法。

四、实验结果及分析(所输入得数据及相应得运行结果,运行结果要有提示信息,运行结果采用截图方式给出。

)五、总结与体会(调试程序得心得与体会,若实验课上未完成调试,要认真找出错误并分析原因等。

)调试程序时,出现了许多错误、如:串得堆分配存储结构、串得联接等。

另外还有一些语法上得错误。

由于对所学知识点概念模糊,试验课上未能完成此次上机作业。

后来经过查阅教材,浏览网页等方式,才完成试验。

这次试验出现错误最重要得原因就就是对课本知识点理解不深刻以及编写代码时得粗心。

以后要都去练习、实践,以完善自己得不足。

六、程序清单(包含注释)#include 〈stdio、h>#include 〈malloc。

h〉#include <stdlib。

h〉typedef char Status;int strlen(char *p){inti=0;while(*p++)i++;return i;}typedef struct{ﻩchar *ch;ﻩ// 若就是非空串,则按串长分配存储区,否则ch为NULLint length; // 串长度}HString;// 初始化(产生空串)字符串Tvoid InitString(HString *T){(*T)。

length=0;ﻩ(*T)、ch=NULL;}//生成一个其值等于串常量chars得串TStatus StrAssign(HString *T, char *chars){ﻩint i,j;if((*T)。

实现串的基本操作

实现串的基本操作

实现串的基本操作一、前言在计算机科学中,串(string)是由零个或多个字符组成的有限序列。

它是计算机科学中基本的数据结构之一,常用于文本处理和数据压缩等领域。

串的基本操作包括:串的创建、串的赋值、串的连接、串的比较、子串的提取、插入和删除等。

本文将详细介绍这些操作。

二、串的创建1. 静态创建静态创建是指在程序运行前就已经确定了字符串内容,并将其存储在静态存储区中。

这种方式通常用于存储不会发生变化的字符串,如程序中使用的提示信息等。

静态创建示例:char str[] = "Hello, world!";2. 动态创建动态创建是指在程序运行时根据需要动态分配内存空间来存储字符串。

这种方式通常用于存储需要动态改变的字符串,如用户输入的信息等。

动态创建示例:char *str = (char*)malloc(sizeof(char)*20);strcpy(str, "Hello, world!");三、串的赋值1. 直接赋值直接赋值是指将一个已有字符串直接赋给另一个字符串。

直接赋值示例:char str1[] = "Hello";char str2[10];str2 = str1;2. 字符数组赋值字符数组赋值是指将一个字符数组中的内容赋给另一个字符数组。

字符数组赋值示例:char str1[] = "Hello";char str2[10];strcpy(str2, str1);3. 指针赋值指针赋值是指将一个指向字符串的指针赋给另一个指向字符串的指针。

指针赋值示例:char *str1 = "Hello";char *str2;str2 = str1;四、串的连接串的连接是指将两个字符串合并为一个字符串。

串的连接示例:char str1[] = "Hello";char str2[] = ", world!";strcat(str1, str2);五、串的比较串的比较是指判断两个字符串是否相等。

串的基本操作

串的基本操作

串的基本操作一、实验目的、意义(1)理解串的堆分配存储结构。

(2)理解用它们表示时插入,生成串,联接串与求子串的算法。

(3)根据具体问题的需要,能够设计出相关算法。

二、实验内容及要求说明1:学生在上机实验时,需要自己设计出所涉及到的函数,同时设计多组输入数据并编写主程序分别调用这些函数,调试程序并对相应的输出作出分析;修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

具体要求:定义串的堆分配存储,完成串的基本操作:插入,生成串,联接串,求子串等。

三、实验所涉及的知识点C语言算法、循环算法、串的堆分配存储结构、插入,生成串,联接串与求子串的算法。

四、实验结果及分析(所输入的数据及相应的运行结果,运行结果要有提示信息,运行结果采用截图方式给出。

)五、总结与体会(调试程序的心得与体会,若实验课上未完成调试,要认真找出错误并分析原因等。

)调试程序时,出现了许多错误。

如:串的堆分配存储结构、串的联接等。

另外还有一些语法上的错误。

由于对所学知识点概念模糊,试验课上未能完成此次上机作业。

后来经过查阅教材,浏览网页等方式,才完成试验。

这次试验出现错误最重要的原因就是对课本知识点理解不深刻以及编写代码时的粗心。

以后要都去练习、实践,以完善自己的不足。

六、程序清单(包含注释)#include <>#include <>#include <>typedef char Status;int strlen(char *p){int i=0;while(*p++)i++;return i;}typedef struct{char *ch; ength=0;(*T).ch=NULL;}h)free((*T).ch); h = NULL;(*T).length = 0;}else{h = (char*)malloc(i*sizeof(char)); h) h[j] = chars[j];(*T).length = i;}return 1;}h)free((*T).ch); h=(char*)malloc*sizeof(char)); h) h[i]=[i];(*T).length=;return 1;}h){free((*S).ch);(*S).ch=NULL;}(*S).length=0;return 1;}h)free((*T).ch); ength=+;(*T).ch=(char *)malloc((*T).length*sizeof(char)); h) exit(0);for(i=0;i<;i++) h[i]=[i];for(i=0;i<;i++) h[+i]=[i];return 1;}h)free((*Sub).ch); h=NULL;(*Sub).length=0;}else{ h=(char*)malloc(len*sizeof(char));if(!(*Sub).ch)exit(0);for(i=0;i<=len-1;i++)(*Sub).ch[i]=[pos-1+i];(*Sub).length=len;}return 1;}ength+1) h = (char*)realloc((*S).ch,((*S).length+*sizeof(char));if(!(*S).ch)exit(0);for(i=(*S).length-1;i>=pos-1;--i) h[i+]=(*S).ch[i];for(i=0;i<;i++)(*S).ch[pos-1+i]=[i]; ength+=;}return 1;}ength<pos+len-1)exit(0);for(i=pos-1;i<=(*S).length-len;i++)(*S).ch[i]=(*S).ch[i+len];(*S).length-=len;(*S).ch=(char*)realloc((*S).ch,(*S).length*sizeof(char));return 1;}// 用V替换主串S中出现的所有与T相等的不重叠的子串int Replace(HString *S,HString T,HString V){int i=1; // 从串S的第一个字符起查找串Tif(StrEmpty(T)) // T是空串return 0;do{i=Index(*S,T,i); // 结果i为从上一个i之后找到的子串T的位置if(i) // 串S中存在串T{StrDelete(S,i,StrLength(T)); // 删除该串TStrInsert(S,i,V); // 在原串T的位置插入串Vi+=StrLength(V); // 在插入的串V后面继续查找串T }}while(i);return 1;}void DestroyString(){// 堆分配类型的字符串无法销毁}// 输出T字符串void StrPrint(HString T){int i;for(i=0;i<;i++)printf("%c",[i]);printf("\n");}int main(){int i;char c,*p="God bye!",*q="God luck!";// HString类型必需初始化InitString(&t);InitString(&s);InitString(&r);StrAssign(&t,p);printf("串t为: ");StrPrint(t);printf("串长为%d 串空否%d(1:空 0:否)\n",StrLength(t),StrEmpty(t)); StrAssign(&s,q);printf("串s为: ");StrPrint(s);i=StrCompare(s,t);if(i<0)c='<';else if(i==0)c='=';elsec='>';printf("串s%c串t\n",c);Concat(&r,t,s);printf("串t联接串s产生的串r为: ");StrPrint(r);StrAssign(&s,"oo");printf("串s为: ");StrPrint(s);StrAssign(&t,"o");printf("串t为: ");StrPrint(t);Replace(&r,t,s);printf("把串r中和串t相同的子串用串s代替后,串r为:\n");StrPrint(r);ClearString(&s);printf("串s清空后,串长为%d 空否%d(1:空 0:否)\n",StrLength(s),StrEmpty(s));SubString(&s,r,6,4);printf("串s为从串r的第6个字符起的4个字符,长度为%d 串s为: ", ;StrPrint(s);StrCopy(&t,r);printf("复制串t为串r,串t为: ");StrPrint(t);StrInsert(&t,6,s);printf("在串t的第6个字符前插入串s后,串t为: ");StrDelete(&t,1,5);printf("从串t的第1个字符起删除5个字符后,串t为: ");StrPrint(t);printf("%d是从串t的第1个字符起,和串s相同的第1个子串的位置\n", Index(t,s,1));printf("%d是从串t的第2个字符起,和串s相同的第1个子串的位置\n", Index(t,s,2));system("pause");return 0;}。

数据结构(串)

数据结构(串)

数据结构(串)数据结构(串)数据结构中的串(String)是由字符构成的有限序列。

在计算机科学中,串是一种基本的数据结构,被广泛应用于字符串处理、文本搜索、模式匹配等领域。

1. 串的定义和基本操作串可以使用多种方式来定义和表示,常见的方式有:- 定长顺序存储表示:使用数组来存储串,数组的长度和最大串长相等,不足的部分用特定字符填充(通常用空格)。

- 堆分配存储表示:使用堆(动态内存分配区)来存储串,可以根据实际需要动态分配和释放串的存储空间。

- 串的块链存储表示:将串分成多个块,将每个块使用链表进行表示,将各块在一起组成完整的串。

串的基本操作包括:- 串的赋值:将一个串赋值给另一个串。

- 串的连接:将两个串按顺序连接成一个新的串。

- 串的比较:比较两个串的大小关系。

- 串的截取:从一个串中截取出一段子串。

- 串的插入:将一个串插入到另一个串的指定位置。

- 串的删除:删除一个串中指定位置的字符或一段子串。

- 串的替换:将一个串中指定位置的字符或一段子串替换成另一个串。

2. 串的匹配算法串的匹配是指在一个主串中查找一个模式串的过程。

常见的串匹配算法包括:- 朴素匹配算法:也称为暴力匹配算法,是最简单的匹配算法。

它从主串的第一个字符开始,与模式串逐个字符进行比较,若不匹配,则主串向后移动一位,直到找到匹配的子串或主串遍历完。

- KMP算法:即Knuth-Morris-Pratt算法,通过利用模式串自身的信息,减少字符的比较次数。

该算法具有线性时间复杂度,是一种高效的匹配算法。

- Boyer-Moore算法:基于模式串中的字符发生不匹配时的启发式策略,通过跳跃式地移动模式串,减少字符的比较次数,从而提高匹配效率。

3. 串的应用串作为一种基本的数据结构,在实际应用中具有广泛的用途,主要包括以下几个方面:- 字符串处理:串在文本编辑、编译器设计、语法分析、文件操作等方面都有广泛应用。

- 模式匹配:串的匹配算法常被用于字符串搜索、DNA序列分析、信息检索等领域。

串的基本操作和简程序实验心得

串的基本操作和简程序实验心得

串的基本操作包括:1. 创建串:使用字符串常量或字符数组来创建一个串。

2. 初始化串:将串中的所有元素设置为一个特定的值。

3. 拷贝串:将一个串的内容复制到另一个串中。

4. 连接串:将两个或多个串连接在一起,形成一个新的串。

5. 求串长度:返回串中元素的个数。

6. 判断子串:检查一个串是否包含在另一个串中。

7. 查找子串:在一个串中查找指定子串的位置。

8. 替换子串:将一个串中的某个子串替换为另一个子串。

9. 插入子串:在指定位置插入一个子串。

10. 删除子串:从指定位置开始,删除指定长度的子串。

11. 截取子串:从指定位置开始,截取指定长度的子串。

12. 逆置串:将串中的元素顺序颠倒。

13. 遍历串:访问串中的每个元素。

以下是一个简单的C语言程序,用于实现上述操作:```c#include <stdio.h>#include <string.h>#include <stdlib.h>void create_string(char *str, const char *s);void init_string(char *str, char c);void copy_string(char *dest, const char *src);void concatenate_strings(char *dest, const char *s1, const char *s2); int length_string(const char *str);int substring_exists(const char *str, const char *sub);int find_substring(const char *str, const char *sub);void replace_substring(char *str, const char *old, const char *new); void insert_substring(char *str, int pos, const char *sub);void delete_substring(char *str, int pos, int len);void substring(char *dest, const char *str, int pos, int len);void reverse_string(char *str);void traverse_string(const char *str);int main() {char str1[100], str2[100], result[200];int pos = 2;int len = 3;int found = -1;int index = -1;const char *old = "world";const char *new = "everyone";const char *sub = "hello";const char *s1 = "Hello, ";const char *s2 = "world!";create_string(str1, "Hello");create_string(str2, "world");init_string(result, '-');concatenate_strings(result, s1, s2);printf("Concatenated string: %s", result);printf("Length of string: %d", length_string(result));found = substring_exists(result, sub);printf("Substring exists: %d", found);index = find_substring(result, sub);printf("Substring index: %d", index);replace_substring(result, old, new);printf("Replaced string: %s", result);insert_substring(result, pos, sub);printf("Inserted string: %s", result);delete_substring(result, pos, len);printf("Deleted string: %s", result);substring(result, result + index + strlen(sub), pos, len);printf("Substring after deletion: %s", result);reverse_string(result);printf("Reversed string: %s", result);traverse_string(result);return 0;}```实验心得:通过这个简单的程序,我了解了串的基本操作和实现方法。

第4章 串

第4章 串

第四章串讲课提要【主要内容】1.串的有关概念及基本操作2.串的存储结构3.串操作应用举例【教学目标】1.掌握串的有关概念及基本运算2.熟悉串的存储结构3.熟悉串操作应用举例学习指导1.概念和术语•串(String)(或字符串):是由零个或多个字符组成的有限序列。

一般记为s= “a1a2…an”(n≥0)其中,s是串的名,用双引号括起来的字符序列是串的值。

•串的长度:串中字符的个数n。

•子串和主串:串中任意个连续的字符组成的子序列称为该串的子串。

包含子串的串相应地称为主串。

•空串:不包含任何字符的串,表示为“Ф”。

•空格串:由一个或多个空格字符组成的串。

例如:“”。

2.串的基本操作(1)用串变量赋值assign(s,t)和用串常量赋值create(s,ss)(2)判等函数equal(s, t)(3)求长函数length(s)(4)连接函数concat(s,t)(5)求子串函数substring(s, pos , len)(6)定位函数index(s,t)(7)置换函数replace(s,t,v)(8)插入子串insert(s,pos,t)(9)删除子串delete(s,pos,k)(10)串的复制copy(s,t)【例3-1】已知字符串:a=“an apple”,b=“other hero”,c=“her”,求:(1)concat(substr(a,1,2),b)。

(2)replace(a,substr(a,5,1),c)。

(3)index(a,c)和index(b,c)。

解:(1)返回值为“another hero”,其中substr(a,1,2)的返回值为“an”。

(2)返回值为“an aherherle”,其中sub(a,5,1)的返回值为“p”。

(3)返回值分别为0和3。

3.串的顺序存储结构(顺序串)串的顺序存储方式类似于线性表的顺序存储方式,其存储结构用C语言描述为:typedef struct strnode {char data[maxlen];int len;}SeqString; //定义顺序串类型【例3-2】设定串采用顺序存储结构,写出对串s1和串s2比较大小的算法。

数据结构串基本操作代码

数据结构串基本操作代码

数据结构串基本操作代码串是由零个或多个字符组成的有限序列,是数据结构中的一种基本数据类型。

常见的串操作有串的存储、串的插入、串的删除、串的替换、串的连接、串的比较等。

以下是对串基本操作的代码实现:1.串的存储串的存储可以使用数组或链表来实现。

下面是基于数组的实现方式。

```C++#define MAX_LEN 100 // 定义串的最大长度typedef structchar data[MAX_LEN]; // 存储串的字符数组int length; // 当前串的长度} String;//初始化串void InitString(String &s)s.length = 0;//串赋值void AssignString(String &s, char str[])int len = strlen(str);for (int i = 0; i < len; i++)s.data[i] = str[i];}s.length = len;//输出串void PrintString(String s)for (int i = 0; i < s.length; i++)cout << s.data[i];}cout << endl;```2.串的插入在指定位置上插入指定内容。

```C++//串的插入void InsertString(String &s, int pos, char str[]) int len = strlen(str);if (s.length + len > MAX_LEN)return; // 串已满,无法插入for (int i = s.length - 1; i >= pos; i--)s.data[i + len] = s.data[i];}for (int i = pos, j = 0; j < len; i++, j++)s.data[i] = str[j];}s.length += len;```3.串的删除删除指定位置上的字符。

串的基本操作

串的基本操作

1上机实训3:串的基本操作一、实训目的通过实训,掌握串的运算(赋值,比较,联结,插入子串,模式匹配……等)二、实验理论知识1)串的基本概念及其含义串( string)是由零个或多个字符组成的有限序列,一般记作:s='a1a2…an'(n≥0),其中s为串的名字,用单引号括起来的字符序列为串的值;ai(1≤i≤n)可以是字母、数字或其它字符(取决于程序设计语言所使用的字符集);n为串中字符的个数,称为串的长度。

2)串的存储表示及其实现●顺序存储可以用一组地址连续的存储单元依次存放串的各个字符,这是串的顺序存储结构,也称为顺序串●链式存储和线性表的链式存储结构相类似,也可采用链表方式存储串值。

串的这种链式存储结构简称为链串。

用链表存储字符串,每个结点需要有两个域:一个数据域(data)和一个指针域(Next),其中数据域存放串中的字符,指针域存放后继结点的地址。

3)模式匹配问题三、实训案例与分析【实例1】串的存储与基本运算【实例分析】在本实例中练习计算字符串的长度、字符串的复制、字符串的比较、字符串的连接、字符串的插入等基本操作。

在设计时1)编写一个菜单函数,根据不同情况做(1-5)不同选择。

2)如果选择1,即要求计算输入字符串的长度。

3)如果选择2,完成字符串的复制。

4)如果选择3,完成字符串的比较。

5)如果选择4,完成两个字符串的连接。

6)如果选择5,字符串的插入。

【参考程序】#include <stdio.h>#define MAX 128typedef enum {fail,success} status;typedef enum {false,true} boolean;main(){ int strlen();void strass();boolean strcmp();status strcat( );status strins();int t,n,i;boolean b;status st;char s[MAX],s1[MAX],s2[MAX];printf("\n1. The length of string\n");printf(" 2. The assignment of string\n");printf(" 3. A string compare with another string:\n"); printf(" 4. A string connect with another string:\n"); printf(" 5. A string to be inserted into another string\n"); printf(" Please input a operation:");/*输入操作选项*/ scanf("%d",&t);switch(t){case 1:printf("please input a string:\n");getchar();gets(s);n=strlen(s);printf("the length is: %d",n);break;case 2:printf("please input the first string:\n");getchar();gets(s1);printf("please input the second string:\n");getchar();gets(s2);strass(s1,s2);break;case 3:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string: \n"); gets(s2);b=strcmp(s1,s2);if (b==true)printf("equal\n");elseprintf("not equal\n");break;case 4:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string:\n"); gets(s2);st=strcat(s1,s2);if(st==success)printf("answer is %s\n",s1);elseprintf("error!\n");break;case 5:printf("please input the first string:\n"); getchar();gets(s1);printf("please input the second string:\n"); gets(s2);printf("please input i:");scanf("%d",&i);st=strins(s1,i,s2);if(st==success)printf("answer is: %s\n",s1);else printf("error!\n");break;case 0:break;default: printf("There isn't this operation!");}}int strlen(s) /*求字符串的长度子函数*/char s[];{ int i;for(i=0;s[i]!='\0';i++);return (i);}void strass(s1,s2)char s1[],s2[];{ int i=0;while(s1[i]!='\0'){ s2[i]=s1[i];i++;}s2[i]='\0';printf("s2 is %s",s2);}boolean strcmp(s1,s2) /*字符串比较子函数*/ char s1[],s2[];{ int i=0;while (s1[i]==s2[i] && s1[i]!='\0' && s2[i]!='\0') i++;if (s1[i]=='\0' && s2[i]=='\0')return (true);elsereturn (false);}status strcat (s1,s2) /*字符串连接子函数*/char s1[],s2[];{ int i,j,k;i=strlen(s1);j=strlen(s2);if((i+j)>=MAXN)return(fail);for(k=0;k<=j;k++)s1[i+k]=s2[k];return (success);}status strins (s1,i,s2)char s1[],s2[];int i;{ int m,n,k;m=strlen(s1);n=strlen(s2);if (i<0||i>m||(m+n)>MAXN )return (fail) ;for(k=m;k>=i;k--)s1[k+n]=s1[k];for(k=0;k<n;k++)s1[i+k]=s2[k];return (success);}【测试数据与结果:】计算字符串的长度1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:1please input a string:you are a boy!the length is: 14字符串的复制1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:2please input the first string:you are a boy!please input the second string:i am a girl!s2 is you are a boy!字符串的比较1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another string Please input a opertation:3please input the first string:you are a boy!please input the second string:i am a girl!not equal字符串的连接1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another stringPlease input a opertation:4please input the first string:you are a boy!please input the second string:i am a girl!answer is:you are a boy!i am a girl!字符串的插入1. The length of string2. The assignment of string3. A string compare with another string:4. A string connect with another string:5. A string to be inserted into another stringPlease input a opertation:5please input the first string:you are a boy!please input the second string:i am a girl!please input i:2answer is i am a girl! you are a boy!【实例2】统计主串指定单词在主串中出现的次数和位置【实例描述】统计主串指定单词在主串中出现的次数和位置,要求:1)输入以回车作为结束符的一串字符作为主串;2)求主串中指定单词出现的次数和位置,注意单词与子串的区别;【实例分析】假设num存放出现次数,初始化为0,position[i]存放每一次匹配时的位置。

串的基本操作

串的基本操作

实验报告题目:串的基本操作,串的复制、连接、比较、赋值、求子串、求长度、模式匹配。

班级:计算机软件组员:一、需求分析1.本程序的目的是了解串的定长存储表示。

进行一系列基本操作,串的复制、连接、比较、赋值、求子串、求长度、模式匹配方式。

2.程序执行的命令包括:1)创建一个定长存储串;2)串的复制;3)串的连接; 4)串的比较; 5)串的赋值;6)求子串;7)求串长;8)串的模式匹配。

二、概要设计1、抽象数据类型定义如下:ADT List {数据对象:D={ai|a i∈CharacterSet,i=1,2,…,n,n>=0}数据关系:R1={< ai-1,ai>|ai-1,a i∈D,i=1,2,…,n}基本操作:StrAssign(&T,char)初始条件:chars是字符串常量。

操作结果:生成一个其值等于chars的串T。

StrCopy(&T,S)初始条件:串s存在。

操作结果:由串S复制得串T。

Length(S)初始条件:串S存在。

操作结果:返回串的长度。

SubString( &Sub,S, pos,len)初始条件:串S存在,1<=pos<=Length(S)且0<=len<=Length(S)-pos+1。

操作结果:用Sub返回串S的第pos个字符起长度为len的子串。

Concat(&T,S2,S3)初始条件:串S2和S3存在。

操作结果:用T返回有S2和S3连接而成的新串。

StrCompare( S4, T1)初始条件:串S4和T1存在。

操作结果:若S4>T1,则返回值>0;若S4=T1,则返回值=0;若S4<T1,则返回值<0.Index_KMP(S,T,pos)初始条件:串S和T存在,T是非空串1<=pos<=Length(S). 操作结果:若主串S中存在和串T值相同的子串,则返回它在主串S中第pos个字符之后第一次出现的位置,否则函数值为0.}三、详细设计定长存储方式:typedef unsigned char SString[MAXSTRLEN+1];int StrAssign(SString S) //输入串。

java串的基本操作

java串的基本操作

java串的基本操作Java串是指由一系列字符组成的字符串,是Java中常用的数据类型之一。

Java串的基本操作包括创建、赋值、比较、连接、截取等。

1. 创建Java串Java中创建串的方式有两种:使用字符串字面值和使用字符串构造函数。

使用字符串字面值创建串的方式非常简单,只需要将一系列字符用双引号括起来即可,例如:String str = "Hello World!";使用字符串构造函数创建串的方式也很简单,只需要调用String类的构造函数即可,例如:String str = new String("Hello World!");2. 赋值Java串Java中可以使用赋值语句将一个串赋值给另一个串,例如:String str1 = "Hello World!";String str2 = str1;这样,str2就和str1指向同一个串。

3. 比较Java串Java中可以使用equals()方法比较两个串是否相等,例如:String str1 = "Hello World!";String str2 = "Hello World!";if(str1.equals(str2)){System.out.println("str1和str2相等");}4. 连接Java串Java中可以使用"+"运算符将两个串连接起来,例如:String str1 = "Hello";String str2 = "World!";String str3 = str1 + " " + str2;System.out.println(str3);这样,str3的值就是"Hello World!"。

5. 截取Java串Java中可以使用substring()方法截取一个串的子串,例如:String str1 = "Hello World!";String str2 = str1.substring(6, 11);System.out.println(str2);这样,str2的值就是"World"。

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

串的基本操作一、实验目的、意义(1)理解串的堆分配存储结构。

(2)理解用它们表示时插入,生成串,联接串与求子串的算法。

(3)根据具体问题的需要,能够设计出相关算法。

二、实验内容及要求说明1:学生在上机实验时,需要自己设计出所涉及到的函数,同时设计多组输入数据并编写主程序分别调用这些函数,调试程序并对相应的输出作出分析;修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

具体要求:定义串的堆分配存储,完成串的基本操作:插入,生成串,联接串,求子串等。

三、实验所涉及的知识点C语言算法、循环算法、串的堆分配存储结构、插入,生成串,联接串与求子串的算法。

四、实验结果及分析(所输入的数据及相应的运行结果,运行结果要有提示信息,运行结果采用截图方式给出。

)五、总结与体会(调试程序的心得与体会,若实验课上未完成调试,要认真找出错误并分析原因等。

)调试程序时,出现了许多错误。

如:串的堆分配存储结构、串的联接等。

另外还有一些语法上的错误。

由于对所学知识点概念模糊,试验课上未能完成此次上机作业。

后来经过查阅教材,浏览网页等方式,才完成试验。

这次试验出现错误最重要的原因就是对课本知识点理解不深刻以及编写代码时的粗心。

以后要都去练习、实践,以完善自己的不足。

六、程序清单(包含注释)#include <stdio.h>#include <malloc.h>#include <stdlib.h>typedef char Status;int strlen(char *p){int i=0;while(*p++)i++;return i;}typedef struct{char *ch; // 若是非空串,则按串长分配存储区,否则ch为NULLint length; // 串长度}HString;// 初始化(产生空串)字符串Tvoid InitString(HString *T){(*T).length=0;(*T).ch=NULL;}// 生成一个其值等于串常量chars的串TStatus StrAssign(HString *T, char *chars){int i,j;if((*T).ch)free((*T).ch); // 释放T原有空间i = strlen(chars); // 求chars的长度iif(!i){// chars的长度为0(*T).ch = NULL;(*T).length = 0;}else{// chars的长度不为0(*T).ch = (char*)malloc(i*sizeof(char)); // 分配串空间if(!(*T).ch) // 分配串空间失败exit(0);for(j = 0; j < i; j++) // 拷贝串(*T).ch[j] = chars[j];(*T).length = i;}return 1;}// 由串S复制得串Tint StrCopy(HString *T,HString S){int i;if((*T).ch)free((*T).ch); // 释放T原有空间(*T).ch=(char*)malloc(S.length*sizeof(char)); // 分配串空间if(!(*T).ch) // 分配串空间失败exit(0);for(i=0;i<S.length;i++) // 拷贝串(*T).ch[i]=S.ch[i];(*T).length=S.length;return 1;}// 若S为空串,则返回1,否则返回0int StrEmpty(HString S){if(S.length == 0 && S.ch == NULL)return 1;elsereturn 0;}// 若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0int StrCompare(HString S,HString T){int i;for(i=0;i<S.length && i<T.length;++i)if(S.ch[i] != T.ch[i])return S.ch[i]-T.ch[i];return S.length-T.length;}// 返回S的元素个数,称为串的长度int StrLength(HString S){return S.length;}// 将S清为空串int ClearString(HString *S){if((*S).ch){free((*S).ch);(*S).ch=NULL;}(*S).length=0;return 1;}// 用T返回由S1和S2联接而成的新串int Concat(HString *T,HString S1,HString S2){int i;if((*T).ch)free((*T).ch); // 释放旧空间(*T).length=S1.length+S2.length;(*T).ch=(char *)malloc((*T).length*sizeof(char)); //分配新串的长度if(!(*T).ch)exit(0);for(i=0;i<S1.length;i++) //将S1接到新串T的后面(*T).ch[i]=S1.ch[i];for(i=0;i<S2.length;i++) //将S2接到新串T的后面(*T).ch[S1.length+i]=S2.ch[i];return 1;}// 用Sub返回串S的第pos个字符起长度为len的子串。

int SubString(HString *Sub, HString S,int pos,int len){int i;if(pos<1||pos>S.length||len<0||len>S.length-pos+1)return 0;if((*Sub).ch)free((*Sub).ch); // 释放旧空间if(!len) // 空子串{(*Sub).ch=NULL;(*Sub).length=0;}else{ // 完整子串(*Sub).ch=(char*)malloc(len*sizeof(char));if(!(*Sub).ch)exit(0);for(i=0;i<=len-1;i++)(*Sub).ch[i]=S.ch[pos-1+i];(*Sub).length=len;}return 1;}// 算法4.1// T为非空串。

若主串S中第pos个字符之后存在与T相等的子串,// 则返回第一个这样的子串在S中的位置,否则返回0int Index(HString S,HString T,int pos){int n,m,i;HString sub;InitString(&sub);if(pos>0){n=StrLength(S);m=StrLength(T);i=pos;while(i<=n-m+1) //从第i个位置开始求与T等长的子串,循环直到找到{SubString(&sub,S,i,m); //从第i个位置开始求得子串if(StrCompare(sub,T)!=0)//将求得的子串与T对比,若不等则i++ ++i;elsereturn i;}}return 0;}// 算法4.4// 在串S的第pos个字符之前插入串Tsint StrInsert(HString *S,int pos,HString T){int i;if(pos<1||pos>(*S).length+1) // pos不合法return 0;if(T.length) // T非空,则重新分配空间,插入T{(*S).ch = (char*)realloc((*S).ch,((*S).length+T.length)*sizeof(char));if(!(*S).ch)exit(0);for(i=(*S).length-1;i>=pos-1;--i) // 为插入T而腾出位置(*S).ch[i+T.length]=(*S).ch[i];for(i=0;i<T.length;i++)(*S).ch[pos-1+i]=T.ch[i]; // 插入T(*S).length+=T.length;}return 1;}// 从串S中删除第pos个字符起长度为len的子串int StrDelete(HString *S,int pos,int len){int i;if((*S).length<pos+len-1)exit(0);for(i=pos-1;i<=(*S).length-len;i++)(*S).ch[i]=(*S).ch[i+len];(*S).length-=len;(*S).ch=(char*)realloc((*S).ch,(*S).length*sizeof(char));return 1;}// 用V替换主串S中出现的所有与T相等的不重叠的子串int Replace(HString *S,HString T,HString V){int i=1; // 从串S的第一个字符起查找串Tif(StrEmpty(T)) // T是空串return 0;do{i=Index(*S,T,i); // 结果i为从上一个i之后找到的子串T的位置if(i) // 串S中存在串T{StrDelete(S,i,StrLength(T)); // 删除该串TStrInsert(S,i,V); // 在原串T的位置插入串Vi+=StrLength(V); // 在插入的串V后面继续查找串T }}while(i);return 1;}void DestroyString(){// 堆分配类型的字符串无法销毁}// 输出T字符串void StrPrint(HString T){int i;for(i=0;i<T.length;i++)printf("%c",T.ch[i]);printf("\n");}int main(){int i;char c,*p="God bye!",*q="God luck!";HString t,s,r;// HString类型必需初始化InitString(&t);InitString(&s);InitString(&r);StrAssign(&t,p);printf("串t为: ");StrPrint(t);printf("串长为%d 串空否?%d(1:空0:否)\n",StrLength(t),StrEmpty(t));StrAssign(&s,q);printf("串s为: ");StrPrint(s);i=StrCompare(s,t);if(i<0)c='<';else if(i==0)c='=';elsec='>';printf("串s%c串t\n",c);Concat(&r,t,s);printf("串t联接串s产生的串r为: ");StrPrint(r);StrAssign(&s,"oo");printf("串s为: ");StrPrint(s);StrAssign(&t,"o");printf("串t为: ");StrPrint(t);Replace(&r,t,s);printf("把串r中和串t相同的子串用串s代替后,串r为:\n");StrPrint(r);ClearString(&s);printf("串s清空后,串长为%d 空否?%d(1:空 0:否)\n",StrLength(s),StrEmpty(s));SubString(&s,r,6,4);printf("串s为从串r的第6个字符起的4个字符,长度为%d 串s为: ", s.length);StrPrint(s);StrCopy(&t,r);printf("复制串t为串r,串t为: ");StrPrint(t);StrInsert(&t,6,s);printf("在串t的第6个字符前插入串s后,串t为: ");StrPrint(t);StrDelete(&t,1,5);printf("从串t的第1个字符起删除5个字符后,串t为: ");StrPrint(t);printf("%d是从串t的第1个字符起,和串s相同的第1个子串的位置\n", Index(t,s,1));printf("%d是从串t的第2个字符起,和串s相同的第1个子串的位置\n", Index(t,s,2));system("pause");return 0;}。

相关文档
最新文档