数据结构的串操作

合集下载

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

实验日期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语言水平有待提高。

数据结构之串的操作及表现

23:26:58
1
4.1 串的抽象数据类型的定义 4.2 串的表示和实现 4.3 串的模式匹配算法
23:26:58 2
4.1 串的抽象数据类型的定义如下：
ADT String {
数据对象：
串是有限长的字符序列，由一对双引号相括，如: a string
D＝{ ai |ai∈CharacterSet, i=1,2,...,n, n≥0 }
23:26:58 11
Concat (&T, S1, S2)
初始条件：串 S1 和 S2 存在。操作结果：用 T 返回由 S1 和 S2 联接而成的新串。
例如： Concate( T, man, kind)
求得 T = mankind
23:26:58 12
SubString (&Sub, S, pos, len)
1≤pos≤StrLength(S)。
操作结果：若主串 S 中存在和串 T 值相同的子串, 则返回它在主串 S 中第pos个字符之后第一次出现的位置; 否则函数值为0。
23:26:58 16
“子串在主串中的位置”意指子串
中的第一个字符在主串中的位序。假设 S = abcaabcaaabc , T = bca Index(S, T, 1) = 2;
// T为非空串。若主串S中第pos个字符之后存在与 T相等的子串， // 则返回第一个这样的子串在S中的位置，否则返回0
if (pos > 0) { n = StrLength(S); m = StrLength(T); i = pos; while ( i <= n-m+1) {
SubString (sub, S, i, m); if (StrCompare(sub,T) != 0) ++i ; else return 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，表示两个串相等。

数据结构顺序串基本操作实验报告

数据结构顺序串基本操作实验报告实验目的：1.掌握顺序串的定义和基本操作；2.掌握顺序串的插入、删除、查找等基本操作。

实验内容：实现顺序串的基本操作，包括串的初始化、插入、删除、查找、输出等操作，并通过实例测试验证操作的正确性。

实验原理：顺序串是一种以连续的存储空间来存储字符序列的数据结构。

在顺序串中，字符串的字符元素依次存储在一组连续的存储单元中，可以通过下标来访问和修改元素。

顺序串的基本操作包括初始化、插入、删除、查找等。

1.串的初始化：初始化一个空串，即将串的长度设置为0。

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

首先需要判断插入位置的合法性，即位置不能超过当前串的长度，并将插入位置后的元素后移一位，然后将要插入的元素放入指定位置。

3.串的删除：删除指定位置的字符或字符串。

首先需要判断删除位置的合法性，即位置不能超过当前串的长度，然后将删除位置后的元素前移一位。

4.串的查找：在串中查找指定字符或子串第一次出现的位置。

遍历串中的每个元素，检查是否与要查找的字符或子串相等，若相等则返回其位置。

5.串的输出：将串中的元素打印出来。

实验步骤：1.定义顺序串的数据结构。

使用数组来存储字符序列，并定义一个变量用于记录串的长度。

2.初始化一个空串。

将串的长度设置为0。

3.实现插入操作。

根据插入位置的合法性，判断是否需要进行插入操作。

如果插入位置超过了当前串的长度，则将元素插入到串末尾；否则，将插入位置后的元素后移一位，并将要插入的元素放入指定位置。

4.实现删除操作。

根据删除位置的合法性，判断是否需要进行删除操作。

如果删除位置超过了当前串的长度，则无需删除；否则，将删除位置后的元素前移一位。

5.实现查找操作。

遍历串中的每个元素，检查是否与要查找的字符或子串相等，若相等则返回其位置。

6.实现输出操作。

遍历串中的每个元素，将其打印出来。

7.构造测试实例，并进行验证。

实验结果：以插入、删除、查找等操作为例，构造测试实例进行验证：假设有一个空串，插入字符'A'到位置0：结果为"A"；在串的末尾插入字符'B'：结果为"AB"；在位置1插入字符'C'：结果为"ACB"；删除位置3的字符：结果为"AC"；查找字符'C'的位置：结果为1实验总结：本次实验主要是对顺序串的基本操作进行了实现和验证。

数据结构(串)

数据结构(串)数据结构(串)1.介绍1.1 定义数据结构(串)是计算机科学中的一种基础数据结构，用于存储和操作一系列具有相同数据类型的元素的集合。

1.2 特性- 顺序存储：串中的元素按照在字符串中的顺序存储。

- 长度可变：可以动态改变串的长度。

- 计数方式：通常使用0开始计数。

1.3 应用字符串的数据结构广泛应用于文本处理、模式匹配、编译器设计等领域。

2.串的基本操作2.1 创建串：定义一个字符串变量并为其分配内存空间。

2.2 销毁串：释放字符串变量占用的内存空间。

2.3 清空串：将字符串中的元素清空，使字符串变为空串。

2.4 判断串是否为空：判断字符串是否为空串。

2.5 获取串的长度：获取字符串中元素的个数。

2.6 拷贝串：将一个串拷贝到另一个串中。

2.7 两个串：将两个串连接成一个新的串。

2.8 截取子串：从原串中截取一段子串。

2.9 查找子串：在串中查找指定子串的位置。

2.10 替换子串：在串中将指定子串替换成新的子串。

2.11 插入子串：在串中指定位置插入一个子串。

2.12 删除子串：从串中删除指定的子串。

3.串的存储结构3.1 顺序存储结构：使用一维数组存储字符串的字符元素。

3.2 链式存储结构：使用链表存储字符串的字符元素，每个节点存储一个字符。

4.串匹配算法4.1 暴力匹配算法：逐个比较字符串中的字符，若匹配失败则向后移动。

4.2 KMP算法：利用前缀函数预处理，避免重复比较已经匹配的字符。

4.3 Boyer-Moore算法：从匹配串的末尾开始比较，利用坏字符规则和好后缀规则跳过不必要的比较。

5.附件本文档不涉及附件。

6.法律名词及注释- 数据结构：指计算机科学中研究数据存储方式及其相关操作的学科。

- 串：也称为字符串，是由零个或多个字符组成的有序序列。

数据结构+串操作(C语言版)

串相等：称两个串是相等的，是指两个串的长度相等且对应字符都相等
1
例如，有下列四个串a，b，c，d： a= “Welcome to Beijing” b= “Welcome” 注意:双引号是为字符串区别于变量名而设,它不 c= “Bei” 是字符串的内容 d= “welcometo” 例如，有下列四个串a，b，c，d： a= “program” b= “Program” c= “pro” 串长？字串？ d= “program”
str.len=s.len-j+t.len; return str; }
20
(10) DispStr(s) 输出串s的所有元素值。
void DispStr(SqString s) { int i;
if (s.len>0)
{ for (i=0;i<s.len;i++) printf("%c",s.data[i]);
#define MaxSize 100
typedef struct { char data[MaxSize]; int len; } SqString;
其中,data域用来存储字符串,len域用来存储字符串的当前长度,MaxSize常量表示允许所存储字符串的最大长度。在C语言中每个字符串以'\0'标志结束。
(3) StrEqual(s,t):判串相等:若两个串s与t相等则返回
真；否:求串长:返回串s中字符个数。
4
(5) Concat(s,t):串连接:返回由两个串s和t连接在一起形成的新串。 (6)SubStr(s,i,j): 求子串 : 返回串 s 中从第 i(1≤i≤StrLength(s))个字符开始的、由连续j个字符组成的子串。 (7)InsStr(s1,i,s2): 将串 s2 插入到串 s1 的第 i(1≤i≤StrLength(s)+1)个字符中,即将s2的第一个字符作为s1的第i个字符,并返回产生的新串。

数据结构串操作源代码

数据结构串的操作1.头文件：//串类的定义class AString{private:char *ch; //串存放数组int curLength; //串的实际长度int maxSize; //存放数组的最大长度.void CheckMem(); //检测内存是否申请成功public:AString();AString(int sz); //构造函数,构造一个最大长度为sz,实际长度为0的字符串AString(const char *init); //构造函数,构造一个最大长度为maxSize,由init 初始化的新字符串对象AString(const AString &ob); //复制构造函数,由一个已有的字符串对象ob 构造一个新字符串~AString(){delete[] ch;} //析构函数,释放动态分配的串空间并撤销该字符串对象//与字符串对象的比较运算int operator == (AString &ob)const {return strcmp(ch,ob.ch) == 0;} //判断当前实例是否与ob串相等,若相等则返回1,否则返回0int operator != (AString &ob)const {return strcmp(ch,ob.ch) != 0;} //判断当前实例是否与ob串不等,若不等则返回1,否则返回0int operator < (AString &ob)const {return strcmp(ch,ob.ch)<0;} //判断当前实例串是否小于ob串,若小于则返回1,否则为0int operator > (AString &ob)const {return strcmp(ch,ob.ch)>0;}//判断当前实例串是否大于ob串,若小于则返回1,否则为0int operator <= (AString &ob)const {return strcmp(ch,ob.ch)<=0;}//判断当前实例串是否小于等于ob串,若小于等于则返回1,否则为0int operator >= (AString &ob)const {return strcmp(ch,ob.ch)>=0;}//判断当前实例串是否大于等于ob串,若大于等于则返回1,否则为0//与字符串的比较运算int operator == (char *str)const{return strcmp(ch,str) == 0;} //判断当前实例是否与C++串相等,若相等则返回1,否则返回0int operator != (char *str)const{return strcmp(ch,str) != 0;}//判断当前实例是否与C++串不相等,若不等则返回1,否则返回0int operator < (char *str)const {return strcmp(ch,str)<0;}//判断当前实例是否与小于C++串,若小于则返回1,否则返回0int operator > (char *str)const{return strcmp(ch,str)>0;}//判断当前实例是否与大于C++串,若小于则返回1,否则返回0int operator <= (char *str)const{return strcmp(ch,str)<=0;}//判断当前实例是否与小于等于C++串,若小于等于则返回1,否则返回0int operator >=(char *str)const {return strcmp(ch,str)>=0;}//判断当前实例是否与大于等于C++串,若大于等于则返回1,否则返回0AString& operator = (AString &ob); //将串ob赋值给当前实例.AString& operator = (const char *str); //将字符串赋值给字符串对象AString& operator +=(AString &ob); //若当前实例串长度与ob串长度之和不超过maxSize则把ob串接在当前实例的后面.AString& operator +=(const char *str); //若当前实例串长度与str串长度之和不超过maxSize,则把str串接到串对象后面.char& operator[](int i); //取当前实例的第i个字符返回.bool IsEmpty()const{return curLength == 0;} //判空函数int Length() const{return curLength;} //返回当前实例的实际字符长度.//下面主要是常用函数的重载等等，方便各种调用方法void SubString(AString &subs,int index,int length); //从索引index开始截取length长度的字符串返回.AString& Remove(int startIndex,int length); //以索引startIndex开始删除length个字符AString& Insert(int pos,const char *value);void Clear(); //清空当前字符串对象void Output(); //输出};//串类的实现void AString::CheckMem(){if(ch == NULL){cerr<<"内存分配失败!\n";exit(1);}}AString::AString(){maxSize = defaultSize;curLength = 0;ch = new char[maxSize];CheckMem();ch[0] = '\0';}AString::AString(int sz){//串构造函数maxSize = sz;ch = new char[maxSize+1];CheckMem();curLength = 0;ch[0] = '\0';}AString::AString(const char *init){//串构造函数int initLength = strlen(init);maxSize = (initLength > defaultSize) ? initLength : defaultSize;ch = new char[maxSize+1];CheckMem();curLength = initLength;strcpy(ch,init);}AString::AString(const AString &ob){//串对象复制构造函数maxSize = ob.maxSize;ch = new char[maxSize+1];CheckMem();strcpy(ch,ob.ch);curLength = ob.curLength;}AString& AString::operator =(AString &ob){if(&ob != this)//若两个串相等为自我赋值{Clear();curLength = ob.curLength;strcpy(ch,ob.ch);}elsecout<<"字符串自身赋值出错!\n";return *this;}AString& AString::operator =(const char *str){//字符串赋值int strLength = strlen(str);maxSize = strLength>maxSize?strLength:maxSize;Clear();strcpy(ch,str);curLength = strLength;return *this;}AString& AString::operator +=(AString &ob){//字符串对象连接char *tempCH = ch;char *tempOb = ob.ch;int addLength = curLength+strlen(tempOb);maxSize = maxSize>addLength?maxSize:addLength;char *temp = new char[maxSize+1];char *tempT = temp;while(*tempCH!='\0')*tempT++=*tempCH++;while(*tempOb!='\0')*tempT++=*tempOb++;*tempT++='\0';Clear();strcpy(ch,temp);curLength=strlen(ch);delete[] temp;return *this;}AString& AString::operator +=(const char *str){//字符串连接到字符串对象char *tempCH = ch;int addLength = curLength+strlen(str);maxSize = maxSize>addLength?maxSize:addLength;char *temp = new char[maxSize+1];char *tempT = temp;while(*tempCH!='\0')*tempT++=*tempCH++;while(*str!='\0')*tempT++=*str++;*tempT++='\0';Clear();strcpy(ch,temp);curLength=strlen(ch);delete[] temp;return *this;}char& AString::operator [](int i){//读取索引位置上的字符if(i<0||i>curLength){cerr<<"字符下标越界\n";exit(1);}return ch[i];}void AString::SubString(AString &subs,int index,int length) {if(index<0||index+length>maxSize||length<0){cerr<<"或索引或者长度越界\n";exit(1);}if(IsEmpty())cerr<<"字符串对象为空\n",exit(1);else{char *temp = new char[length+1];if(temp==NULL){cerr<<"内存分配错误！\n";exit(1);}for(int i=0,j=index;i<length;i++,j++){temp[i] = ch[j];}temp[length] = '\0';subs=temp;}}AString& AString::Remove(int startIndex,int length){if(startIndex<0||startIndex+length>maxSize||length<0){cerr<<"索引或长度越界\n";exit(1);}if(IsEmpty())cerr<<"字符串对象为空\n",exit(1);for(int i=0;i<curLength-startIndex-length;i++){ch[i+startIndex] = ch[i+length+startIndex];}ch[curLength-length] = '\0';curLength=strlen(ch);return *this;}AString& AString::Insert(int pos,const char *value){if(pos>curLength||pos<0){cerr<<"试图插入的位置越界\n";exit(1);}int addLength = strlen(value) + curLength;maxSize = addLength>maxSize?addLength:maxSize;char *temp = new char[maxSize+1];char *tempCH = ch;char *tempH = temp;for(int i=0;i<pos;i++)*temp++ = *tempCH++;//先将当前对象中插入位置之前的字符复制到tempH指向的内存中while(*value!='\0')*temp++=*value++;//再将待插入的字符串连接到tempH指向的内存中while(*tempCH!='\0')*temp++=*tempCH++;//最后将当前对象插入位置之后的字符连接到tempH指向的内存中*temp='\0';Clear(); //清空当前对象strcpy(ch,tempH);//将拼接好的字符串复制到实例中curLength=strlen(ch);return *this;}void AString::Clear(){delete[] ch;ch = new char[maxSize+1];CheckMem();//释放内存并重新申请ch[0] = '\0';//将串对象置为空curLength = 0;}void AString::Output(){if(IsEmpty())cerr<<"字符串对象为空"<<endl;elsecout<<ch<<endl;}2.主程序：#include<iostream.h>#include"stdio.h"//EOF,NULL#include<string>const int defaultSize = 128;using namespace std;#include"AString.h"int main(){cout<<"------------------------------------------------------------------------"<<endl;cout<<"请输入初始化对象的大小：";int len;cin>>len;char *str = new char[len+1];cout<<"\n请输入要初始化字符串(不能含有空格)：";cin>>str;AString string(len);string = str;int tag=0;while(1){cout<<"1-删除操作\n"<<"2-插入操作\n"<<"3-连接操作\n"<<"4-截取字符串\n"<<"5-字符比较\n"<<"6-输出字符串对象\n"<<"7-清空字符对象(清空后可选择序号8来重新赋值)\n"<<"8-字符串对象赋值\n"<<"9-退出程序\n";cout<<"\n请输入要操作的方法的序号：";cin>>tag;switch(tag){case 1:{int index,length;cout<<"请输入要删除的起始位置：";cin>>index;cout<<"\n请输入要删除的长度：";cin>>length;string.Remove(index,length);cout<<"\n删除后的字符串："<<endl;string.Output();break;}case 2:{int index;char *input = new char[defaultSize];cout<<"\n请输入要插入的字符串：";cin>>input;//cout<<" 输入的串长为："<<strlen(input)<<endl;cout<<"\n请输入要插入的位置：";cin>>index;string.Insert(index,input);cout<<"\n插入字符串后的字符对象："<<endl;string.Output();delete[] input;break;}case 3:{char *value = new char[defaultSize+1];cout<<"\n请输入要连接的字符串：";cin>>value;AString astr = value;string+=astr;cout<<"\n连接字符串后的字符对象："<<endl;string.Output();delete[] value;break;}case 4:{int len,i;AString subs;cout<<"\n请输入要截取的字符串长度：";cin>>len;cout<<"\n请输入开始截取的位置：";cin>>i;string.SubString(subs,i,len);cout<<"\n下面为截取后的字符串对象：";subs.Output();break;}case 5:{char *value = new char[128];cout<<"\n请输入要比较的字符串：";cin>>value;cout<<"\n字符串比较结果如下所示：";string.Output();if(string>value) cout<<">";if(string==value) cout<<"=";if(string<value) cout<<"<";cout<<value<<endl;break;}case 6:cout<<"\n当前字符串对象的值如下所示：";string.Output();break;case 7:string.Clear();cout<<"\n字符串对象已清空！\n";break;case 8:{char *str = new char[128];cout<<"\n请输入要赋值的字符串(不能有空格)：";cin>>str;string = str;cout<<"\n赋值后的字符串对象为：";string.Output();break;}case 9:cout<<"运行结束"<<endl;return 0;break;default:cout<<"选择非法，请重选!";break;}}}。

数据结构chapter4串

PART 05
串的编程实现与性能分析
串的编程实现方法
定长顺序存储
01
使用固定长度的字符数组存储串，适用于串长度已知且变化不
大的情况。
堆分配存储
02
使用动态内存分配技术，在堆区为串分配存储空间，适用于串
长度变化较大的情况。
块链存储
03
将串划分为多个块，每个块包含多个字符，块之间通过链表连
接，适用于需要高效插入和删除操作的情况。
串的基本操作
01
02
03
串的赋值
创建一个空串，并将指定的字符序列赋值给该串。
串的比较
比较两个串是否相等，或者比较它们的字典序大小。
串的连接
将两个串连接起来形成一个新的串。
串的基本操作
01
02
03
04
串的截取
从指定位置开始，截取指定长度的子串。
串的查找
在串中查找指定的子串或字符，并返回其位置。
PART 04
串的应用举例
文本编辑中的串操作
字符串匹配
在文本编辑中，经常需要查找或替换特定的字符串，这可以通过
串的匹配操作实现。
文本排版
文本编辑器需要对输入的文本进行排版，包括段落对齐、行距调整等，这些操作可以通过对字符串的处理来实现。
撤销与重做
文本编辑器需要提供撤销和重做功能，以支持用户对编辑操作的回溯，这可以通过保存和操作字符串的历史记录来实现。
存取速度相对较慢，不支持随机存取。
优点
空间利用率高，能够充分利用存储空间。
块链存储结构
链表
将串的字符分散存储在一系列的块中，每个块包含多个字符。块之间通过指针链接。

数据结构的串操作

数据结构的串操作数据结构的串操作
⒈概述
⑴串的定义
⑵串的基本操作
⒉串的存储结构
⑴顺序存储结构
⑵链式存储结构
⒊串的基本操作
⑴串的长度
⑵串的比较
⑶串的连接
⑷串的截取
⑸串的插入
⑹串的删除
⑺串的替换
⒋字符串匹配算法
⑴朴素模式匹配算法
⑵ KMP 算法
⑶ Boyer-Moore 算法
⑷ Rabin-Karp 算法
附件：
⒈示例代码
⒉数据集
法律名词及注释：
⒈串：在计算机科学中，串（String）是由零个或多个字符组成的有限序列。

⒉顺序存储结构：串的顺序存储结构是将串的字符按线性次序逐个存储在一组地址连续的存储单元里。

⒊链式存储结构：串的链式存储结构是通过定义一个节点类型来存储串的字符，每个节点包含一个字符和一个指向下一个节点的指针。

⒋朴素模式匹配算法：朴素模式匹配算法是最简单的字符串匹
配算法之一，通过对目标串的每个字符依次与模式串进行比较，直
到找到匹配的位置或遍历完所有字符。

⒌ KMP 算法：KMP 算法是一种高效的字符串匹配算法，通过利
用模式串的前缀和后缀信息，在匹配失败时将模式串移动比朴素算
法更远的位置，减少比较次数。

⒍ Boyer-Moore 算法：Boyer-Moore 算法是一种基于多种规则
的字符串匹配算法，通过从右到左比较模式串和目标串的字符，根
据不匹配字符在模式串中的位置和字符表进行移动，提高匹配效率。

⒎ Rabin-Karp 算法：Rabin-Karp 算法是一种利用哈希函数的
字符串匹配算法，通过计算目标串和模式串的哈希值，并逐个比较，减少比较次数。

数据结构-顺序串基本操作实验报告

数据结构\顺序串基本操作实验报告实验报告数据结构\顺序串基本操作一、实验目的本实验旨在通过实践，掌握顺序串的基本操作，包括顺序串的初始化、销毁、插入、删除和查找等。

二、实验内容1\初始化顺序串2\销毁顺序串3\插入元素到顺序串4\删除顺序串中的指定元素5\查找顺序串中的指定元素三、实验步骤1\初始化顺序串顺序串的初始化就是创建一个空顺序串，可以通过创建一个定长数组来实现。

具体步骤如下：（1）定义一个定长数组，例如a[MAX_SIZE]，用于存储顺序串的元素。

（2）定义一个变量len，用于记录顺序串的当前长度，初值为0。

2\销毁顺序串销毁顺序串就是释放顺序串占用的内存空间，具体步骤如下：（1）释放数组a所占用的内存空间。

（2）将len重置为0。

3\插入元素到顺序串插入元素到顺序串就是在指定位置插入一个元素。

具体步骤如下：（1）判断插入位置的合法性，如果位置小于0或大于当前顺序串的长度，即为非法操作。

（2）将len加1，表示顺序串的长度增加了一个。

（3）将插入位置及其之后的元素依次后移一位。

（4）将需要插入的元素存放到插入位置处。

4\删除顺序串中的指定元素删除顺序串中的指定元素就是将顺序串中某个位置的元素删除。

具体步骤如下：（1）判断被删除位置的合法性，如果位置小于0或大于等于当前顺序串的长度，即为非法操作。

（2）将被删除位置之后的元素依次前移一位。

（3）将len减1，表示顺序串的长度减少了一个。

5\查找顺序串中的指定元素查找顺序串中的指定元素就是找出顺序串中第一个与给定元素相等的元素的位置。

具体步骤如下：（1）从顺序串的第一个元素开始逐个与给定元素比较，直到找到相等的元素或搜索到顺序串的末尾。

（2）返回相等元素的位置。

四、实验结果与分析根据实验步骤，我们可以完成顺序串的初始化、销毁、插入、删除和查找等基本操作。

通过这些操作，我们可以对顺序串进行各种元素的插入、删除和查找操作，方便实现顺序串的各种功能。

数据结构(串)

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

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

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

- 堆分配存储表示：使用堆（动态内存分配区）来存储串，可以根据实际需要动态分配和释放串的存储空间。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

《数据结构-串》课件

《数据结构-串》ppt 课件
xx年xx月xx日
• 串的基本概念 • 串的基本操作 • 串的模式匹配算法 • 串的应用 • 总结与展望
目录
01
串的基本概念
串的定义
串
由零个或多个字符组成的有限序列。
长度
串中字符的个数。
空串
长度为零的串。
串的表示
01
02
03
文本表示法
用单引号或双引号括起来的字符序列。
文本编辑器中的串处理
在文本编辑器中，字符串处理功能通常包括字符串的查找、替换、分割、连接、大小写转换等。这些功能可以帮助用户快速处理大量的文本数据，提高工作效率。
文本编辑器中的串处理
在文本编辑器中，字符串处理的应用场景非常广泛。例如，在编写小说或文章时，可以使用查找和替换功能批量修改错别字或格式；在排版报纸或制作简历时，可以使用字符串分割和大小写转换等功能快速整理文本内容。
详细描述
连接串操作需要将两个或多个已存在的字符串对象合并成一个新的字符串对象。在合并过程中，需要将前一个字符串的结尾字符（'0'）替换为特殊字符，以便区分不同的字符串。然后，将后一个字符串的起始位置指向特殊字符，实现两个字符串的连接。
比较串
总结词
比较串是比较两个字符串对象是否相等的过程。
详细描述
适用于模式字符串较短且主字符串长度较小的情况。
KMP算法
总结词
高效的字符串匹配算法，能够避免不必要的比较
时间复杂度
O(n+m)，其中n是主字符串长度，m是模式字符串长度。
详细描述
KMP算法是一种改进的字符串匹配算法，它利用已经匹配过的部分信息，通过一个称为“部分匹配表”或“失败函数”的辅助数据结构，跳过一些不必要的比较，从而提高匹配效率。

数据结构-串

数据结构-串数据结构-串概述：串是由零个或多个字符组成的有限序列，是一种常见的数据类型。

在计算机科学中，串经常被用来表示文本字符串。

本文将介绍串的基本定义、操作以及相关的应用。

1.串的定义1.1 字符集字符集是构成串的基本元素，它包含了一个或多个字符。

1.2 串的长度串的长度是指串中字符的个数，通常用n表示。

1.3 串的表示串的表示可以使用字符数组、指针、链表等方法，具体的表示方法根据实际情况选择。

2.串的基本操作2.1 串的初始化初始化一个空串或者将一个已有的串赋值给另一个串变量。

2.2 串的连接将两个串连接起来形成一个新串。

2.3 串的截取对一个串进行截取，截取出一个子串。

2.4 串的比较比较两个串是否相等或者大小关系。

2.5 串的插入在一个串的指定位置插入一个子串。

2.6 串的删除从一个串中删除指定位置的子串。

2.7 串的替换在一个串中将指定位置的子串替换为另一个子串。

3.串的应用3.1 字符串匹配判断一个串是否包含另一个串，可以使用字符串匹配算法，如朴素模式匹配算法、KMP算法等。

3.2 文本编辑在文本编辑器中对文本进行插入、删除、替换等操作，就是基于串的操作。

3.3 编码解码在计算机通信中，对数据进行编码和解码时，也会使用到串的操作。

3.4 数据压缩在数据压缩算法中，也会使用到串的操作。

本文档涉及附件：无法律名词及注释：1.串：在计算机科学中，串指由零个或多个字符组成的有限序列。

2.字符集：字符集是指包含了一个或多个字符的集合，比如ASCII、Unicode等。

数据结构串基本操作代码

数据结构串基本操作代码简介本文档介绍了数据结构中串的基本操作代码,包括串的定义、串的赋值、串的比较、串的连接、串的替换等。

1.串的定义串是由零个或多个字符组成的有限序列,是字符串的抽象数据类型。

常用的串类型包括顺序串和链式串。

1.1 顺序串顺序串是使用数组来存储字符序列的数据结构。

其定义如下：```cdefine MaXSiZe 100 // 串的最大长度typedef struct {char data[MaXSiZe]； // 存储串的字符数组int length； // 串的长度} SqString；```1.2 链式串链式串是使用链表来存储字符序列的数据结构。

其定义如下：```ctypedef struct LNode {char data； // 存储串的字符struct LNode next； // 指向下一个节点的指针} LNode, LinkString；```2.串的基本操作2.1 串的赋值将一个字符串赋值给一个串,可以使用字符串赋值函数`strcpy`或者循环遍历字符串赋值。

2.1.1 使用strcpy函数赋值```cinclude <string.h>void Strassign(SqString s, char str) {strcpy(s->data, str)；s->length = strlen(str)；}```2.1.2 使用循环遍历赋值```cvoid Strassign(SqString s, char str) {int i；for (i = 0； str[i] ！= '\\0'； i++) {s->data[i] = str[i]；}s->length = i；s->data[i] = '\\0'；}```2.2 串的比较比较两个串是否相等,可以使用字符串比较函数`strcmp`或者循环遍历比较。

数据结构串的赋值操作

数据结构串的赋值操作数据结构是计算机科学中非常重要的概念之一，它用于组织和存储数据，以便于后续的操作和处理。

其中，串（String）是一种特殊的线性表，它由零个或多个字符组成，字符之间按照线性顺序排列。

串的赋值操作是一种常见的操作，它用于将一个串的值赋给另一个串。

本文将从串的定义、串的赋值操作的实现以及应用场景等方面进行介绍。

一、串的定义串是由零个或多个字符组成的有限序列，每个字符都有一个确定的位置。

串的长度是指字符的个数，记作len(S)，其中S表示串。

通常，串的长度从1开始计算。

串中的字符可以是任意字符集中的字符，比如数字、字母、符号等。

例如，"Hello World!"就是一个长度为12的串。

二、串的赋值操作的实现串的赋值操作是将一个串的值赋给另一个串。

在实现串的赋值操作时，常用的方法有两种：直接赋值和逐个字符复制。

1. 直接赋值直接赋值是将一个串的值直接赋给另一个串。

这种方法简单直接，适用于串的内容不需要修改的情况。

例如，假设有两个串S和T，要将S的值赋给T，可以使用以下代码实现：T = S;2. 逐个字符复制逐个字符复制是将一个串中的每个字符逐个复制到另一个串中。

这种方法适用于串的内容需要修改的情况。

例如，假设有两个串S和T，要将S的值复制到T中，可以使用以下代码实现：for (int i = 0; i < len(S); i++) {T[i] = S[i];}T[len(S)] = '\0'; // 添加字符串结束符三、串的赋值操作的应用场景串的赋值操作在实际应用中有广泛的应用场景，以下列举了几个常见的应用场景：1. 字符串拷贝在某些情况下，我们需要将一个串的内容复制到另一个串中，以便于后续的操作。

比如，将一个字符串作为另一个字符串的前缀、后缀或中间部分，可以使用串的赋值操作实现。

2. 字符串替换在文本处理中，有时需要将一个串中的特定字符或字符串替换为另一个字符或字符串。

数据结构串基本操作代码

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

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

以下是对串基本操作的代码实现：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.串的删除删除指定位置上的字符。

数据结构中的串操作详解

s->len++;
return s->len;/*返回统计结果*、
}
串联接
void StrConcat(l,s,t) /*联接串s和串t于串变量l中*/
string *s,*t,*l;
{
int i,j;
if(s->len+t->len>stringlen)
printf("结果串l的长度超过串的定长stringlen!\n");
s->start=free;
free=free+t->length;/*修改堆中指示器变量free的值*/
}
}
l->len=s->len+t->len;/*计算结果串l的串长度*/
}
}
求子串
void SubString(t,s,i,len)
/*将主串S之中第i个字符起的长度为LEN的子串变量t中*/
STRING *t,*s;
int i,len;
{
int j;
if((i<0)||(i>=s->len))
printf("字串的开始位置i越界错误\n");
}
}
字串的定位操作常称作模式匹配，子串t称作模式，在主串s中确定t的位置的过程称作匹配过程。在文本编辑、文件检索和各种串处理系统中有着广泛的应用，是最重要的串运算之一。
如利用串比较、求串长和求子串3中基本操作实现模式匹配的算法：
int StrIndxe(s,t)
/*利用串的基本运算实现模式匹配，匹配成功返回子串位置，否则返回-1*/
else
{
for(i=0;s->ch[i]!='\0';i++)

数据结构的串操作

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

数据结构之串的操作及表现

串的基本操作范文

数据结构顺序串基本操作实验报告

数据结构(串)

数据结构+串操作(C语言版)

数据结构串操作源代码

数据结构chapter4串

数据结构的串操作

数据结构-顺序串基本操作实验报告

数据结构(串)

《数据结构-串》课件

数据结构-串

数据结构 串基本操作代码

数据结构串的赋值操作

数据结构串基本操作代码

数据结构中的串操作详解

数据结构串基本操作代码