串的抽象数据类型
严蔚敏数据结构-第四章 串
15
(2)S1串长 最大串长 串长<最大串长 串长 最大串长; S1,S2串长和 最大串长 串长和>最大串长 串长和 最大串长;
S1 6 a b c d e f S2 6 g h i j k l T 8 a b c d e f g h
3
串的抽象数据类型的定义: 串的抽象数据类型的定义: ADT String{ 数据对象: 数据对象:D={ai|ai∈CharacterSet, i=1,2,...,n, n>=0} 数据关系: 数据关系:R1={<ai-1,ai>|ai-1,ai∈D, i=2,...,n} 基本操作: 基本操作: StrAssign(&T, chars)
11
作业: 作业: 1.用5种串的基本操作(StrAssign、StrCompare、StrLen Concat、SubString)来逻辑实现StrInsert(&S, pos, T)操作 、 操作. )
Status StrInsert(String S, int pos , String T) { if ……….. return error; , , ); ); ); );
chars是字符串常量。生成一个其值等于chars的串 。 是字符串常量。生成一个其值等于 的串T。 是字符串常量 的串
StrCopy(&T, S)
存在则由串S复制得串 串S存在则由串 复制得串 存在则由串 复制得串T
StrEmpty(S)
存在则若S为空串 串S存在则若 为空串 返回真否则返回假 存在则若 为空串,返回真否则返回假
Sub返回串 的第pos个字符起长度为 返回串S的第 个字符起长度为len的子串 用Sub返回串S的第pos个字符起长度为len的子串
数据结构简答题和论述题
数据结构简答题和论述题1、试描述数据结构和抽象数据类型的概念与程序设计语⾔中数据类型概念的区别。
【解答】数据结构是指相互之间存在⼀定关系的数据元素的集合。
⽽抽象数据类型是指⼀个数据结构以及定义在该结构上的⼀组操作。
程序设计语⾔中的数据类型是⼀个值的集合和定义在这个值集上⼀组操作的总称。
抽象数据类型可以看成是对数据类型的⼀种抽象。
串:是零个或多个字符组成的有限序列。
串是⼀种特殊的线性表,它的每个结点仅由⼀个字符组成。
空串 :长度为零的串,它不包含任何字符。
空⽩串 :仅由⼀个或多个空格组成的串⼦串 :串中任意个连续字符组成的⼦序列称为该串的⼦串。
串变量和串常量通常在程序中使⽤的串可分为:串变量和串常量。
(1)串变量 :串变量和其它类型的变量⼀样,其取值是可以改变的。
(2)串常量 :串常量和整常数、实常数⼀样,在程序中只能被引⽤但不能改变其值。
即只能读不能写。
(1)树形图表⽰: 树形图表⽰是树结构的主要表⽰⽅法。
(2)树的其他表⽰法① 嵌套集合表⽰法:是⽤集合的包含关系来描述树结构。
② 凹⼊表表⽰法:类似于书的⽬录③ ⼴义表表⽰法:⽤⼴义表的形式表⽰的。
上图 (a)树的⼴义表表⽰法如下:(A(B(E,F(I,J)), C,D(G,H)))1.中序遍历的递归算法定义:若⼆叉树⾮空,则依次执⾏如下操作:(1)遍历左⼦树; (2)访问根结点; (3)遍历右⼦树。
2.先序遍历的递归算法定义:若⼆叉树⾮空,则依次执⾏如下操作:(1) 访问根结点; (2) 遍历左⼦树; (3) 遍历右⼦树。
3.后序遍历得递归算法定义:若⼆叉树⾮空,则依次执⾏如下操作:(1)遍历左⼦树; (2)遍历右⼦树; (3)访问根结点。
2、链表具有的特点是B 插⼊、删除不需要移动元素C 不必事先估计存储空间D 所需空间与线性表长度成正⽐顺序队列(1)队列的顺序存储结构称为顺序队列,顺序队列实际上是运算受限的顺序表。
(2) 顺序队列的表⽰①和顺序表⼀样顺序队列⽤⼀个向量空间存放当前队列中的元素。
数据结构——第4章 串(C#)
4.1.1 什么是串 串(或字符串)是由零个或多个字符组成的有限序列。 记作str="a1a2…an"(n≥0),其中str是串名,用双引号括 起来的字符序列为串值,引号是界限符,ai(1≤i≤n)是一 个任意字符(字母、数字或其他字符),它称为串的元素, 是构成串的基本单位,串中所包含的字符个数n称为串的 长度,当n=0时,称为空串。
4.2 串的存储结构
4.2.1 串的顺序存储结构-顺序串
和顺序表一样,用一个data数组(大小为MaxSize)和 一个整型变量length来表示一个顺序串,length表示data数 组中实际字符的个数。 定义顺序串类SqStringClass如下:
class SqStringClass { const int MaxSize=100; public char[] data; //存放串中字符 public int length; //存放串长 public SqStringClass() //构造函数,用于顺序串的初始化 { data=new char[MaxSize]; length=0; } //顺序串的基本运算 }
(9)串输出DispStr() 将当前串s的所有字符构成一个字符串并输出。对应的算 法如下:
public string DispStr() { int i; string mystr=""; if (length==0) mystr = "空串"; else { for (i=0;i<length;i++) mystr+=data[i].ToString(); } return mystr; }
数据结构-第4章 串
4.1 串的类型定义
子串的序号:将子串在主串中首次出现时的该 子串的首字符对应在主串中的序号,称为子串 在主串中的序号(或位置)。 【例】 A=“abcdefbbcd”,B=“bcd”,B在A中的 序号为2。 特别地,空串是任意串的子串,任意串是其自 身的子串。
4.1.2 串的抽象数据类型定义
//查找ab子串
if (p->data==‘ a’ && p->next->data==‘b’)
{ p->data=‘x’; p->next->data=‘z’;
q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=‘y’;
q->next=p->next; p->next=q;
s: a a a a b c d
t: a ab bac acb bc c ✓ 匹配成功 算法的思路是从s的每一个字符开始依次与t的 字符进行匹配。
4.2.1 Brute-Force算法
int BFIndex(SqString s,SqString t)
{ int i=0, j=0,k;
while (i<s.length && j<t.length)
4.1 串的类型定义 4.2 串的表示和实现 4.3 串的模式匹配算法
本章要求
理解: 1、串的基本概念、类型定义 2、串的存储表示和实现 3、串的KMP算法
掌握: 4、串的简单模式匹配算法(BF)
第4章 串的基本概念
串(或字符串):是由零个或多个字符组成 的有限序列。
串的逻辑表示: S=“a1a2…ai…an”,其中S为 串名,ai (1≤i≤n)代表单个字符,可以是字母、 数字或其它字符(包括空白符)。 串值:双引号括起来的字符序列。双引号不是 串的内容,只起标识作用。
第3章-字符串
图3.6 p0…pi-1的前缀与后缀比较
2021/4/8
25
k(是0≤p0k…≤pi -i-11串)中。最显大然的这前个缀值与不后但缀存的在长,度而 且仅仅依赖于p本身,与任何t无关。
当右移量小于i-k时,根据k的意义,此时用 长度大于k的前后缀对齐,比较结果必定不相 等。
当右移量大于i-k时,又可能错过目前匹配 成功的机会。
现的位置。
end ADT String
2021/4/8
5
3.2 字符串的实现
顺序表示 链接表示
2021/4/8
6
3.2.1 顺序表示
字符串的顺序表示,就是把串中的字符,顺序地存储在一 组地址连续的存储单元中。其类型定义为:
struct SeqString {
/* 顺序串的类型 */
int MAXNUM;2021/4/8 Nhomakorabea30
例子
• t="aabcbabcaabcaababc" n=18, • p=“abcaababc”, m=9。
feiwlwokucom目录31字符串及其抽象数据类型311基本概念312抽象数据类型32字符串的实现321顺序表示322链接表示33模式匹配331朴素的模式匹配332无回溯的模式匹配31字符串及其抽象数据类型311基本概念字符串简称串是一种特殊的线性表其特殊性主要在于表中的每个元素是一个字符
第三章 字符串
否则必有某个i(0≤i≤m-1),使得ti ≠pi, 这时可将p右移一个字符,用p中字符从头p0开始 与t中字符t1依次比较.
如此反复执行,直到下面两种情况之一:
到达某步时,ti = p0,ti+1 = p1,…,ti+m-1 = pm-1,匹配成功,返回第一次出现的位置是从t中第 i+1个字符ti开始;
数据结构——串
7
三、串的基本操作 C语言中常用的串运算 定义下列几个变量: char s1[20]=“dirtreeformat”,s2[20]=“file.mem”; char s3[30],*p; int result;
(1) 求串长(length) int strlen(char s); //求串的长度
例如:printf(“%d”,strlen(s1)); 输出13
char strcat(char s1 , char s2)
该函数将串s2复制到串s1的末尾,并且返回一 个指向串s1的开始处的指针。
例如:strcat(a3,”/”)
strcat(a3,a2);
2020//4//a143=“dirtreeformat/file.mem”
9
(4)串比较(compare)
A=“This is a string” B=“is” B在A中出现了两次,其中首次出现所对应的主串
位置是3。因此,称B在A中的序号(或位置)为3 特别地,空串是任意串的子串,任意串是其自身的子
串。
2020/4/14
5
二、串的抽象数据定义
• ADT String { • 数据对象:D={ai| ai
16
顺序串的类型定义和顺序表类似: typedef char ElemType;
typedef struct { ElemType ch[maxstrlen]; int length;
}sstring; //其优点是涉及到串长操作时速度快。
2020/4/14
17
4.2.2 堆分配存储表示
这种存储表示的特点是,仍以一组地址连续的存储单元存 放字符串序列,但它们的存储空间是在程序执行过程中动态 分配而得。所以也称为动态存储分配的顺序表。在C语言中, 利用malloc和realloc,free等动态存储管理函数,来根据实 际需要动态分配和释放字符数组空间。这样定义的顺序串类
数据类型及其分类
数据类型及其分类数据类型是程序设计中的基础概念,它定义了数据的特点和操作。
在计算机编程中,数据可以分为不同的类型,每种类型都有其特定的属性和可执行的操作。
本文将详细介绍主要的数据类型及其分类。
一、基本数据类型基本数据类型是编程语言中最基础、最原始的数据类型,它们是构成其他复杂数据类型的基石。
常见的基本数据类型包括以下几种:1. 整型(int):用来表示整数,可以是正数、负数或零,不包含小数部分。
2. 浮点型(float):用来表示带有小数部分的数字,通常具有单精度或双精度两种精度。
3. 字符型(char):用来表示单个字符,可以是字母、数字、标点符号等。
4. 布尔型(bool):用来表示真值,只能取两个值,即真(true)或假(false)。
二、复合数据类型复合数据类型是由多个基本数据类型组合而成的数据类型,它们能够存储更加复杂的数据结构。
常见的复合数据类型包括以下几种:1. 数组(array):是一种由相同类型的元素组成的数据结构,可以按照索引位置来访问每个元素。
2. 字符串(string):是由一串字符组成的数据类型,可以进行字符串的连接、比较等操作。
3. 结构体(struct):是一种用户自定义的数据类型,可以包含多个不同类型的数据成员。
4. 枚举(enum):是一种具有离散取值的数据类型,用于定义一组相关的常量。
三、指针类型指针是一种特殊的数据类型,用于存储变量的内存地址。
通过指针,可以直接访问内存中存储的数据。
指针类型包括以下几种:1. 指针变量(pointer):用于存储其他变量的地址,可以通过指针访问对应地址上的值。
2. 空指针(null pointer):指向空地址的指针,表示它不指向任何有效的内存空间。
3. 野指针(wild pointer):指向非法地址的指针,未初始化或已经释放的指针称为野指针。
四、抽象数据类型抽象数据类型(Abstract Data Type,ADT)是一种高级的数据类型,它将数据和操作封装在一起,提供了一种抽象的方式来理解和使用数据。
串的抽象数据类型的定义.
StrAssign (&T, chars)
初始条件:chars 是字符串常量。 操作结果:把 chars 赋为 T 的值。
StrCopy (&Tቤተ መጻሕፍቲ ባይዱ S)
初始条件:串 S 存在。
操作结果:由串 S 复制得串 T。
DestroyString (&S)
初始条件:串 S 存在。 操作结果:串 S 被销毁。
StrEmpty (S)
SubString (&Sub, S, pos, len)
ClearString (&S) Index (S, T, pos) Replace (&S, T, V) StrInsert (&S, pos, T)
StrDelete (&S, pos, len)
} ADT String
StrDelete (&S, pos, len)
初始条件:串S存在
1≤pos≤StrLength(S)-len+1。
操作结果:从串S中删除第pos个字符
起长度为len的子串。
ClearString (&S) 初始条件:串S存在。 操作结果:将S清为空串。
对于串的基本操作集可以有不同的定义 方法,在使用高级程序设计语言中的串类型 时,应以该语言的参考手册为准。 gets(str) 输入一个串; puts(str) 输出一个串; strcat(str1, str2) 串联接函数; strcpy(str1, str2, k) 串复制函数; strcmp(str1, str2) 串比较函数; strlen(str) 求串长函数;
StrInsert (&S, pos, T)
初始条件:串S和T存在,
抽象数据类型名词解释
抽象数据类型名词解释抽象数据类型抽象数据类型(abstract data type)抽象数据类型是对具体数据类型的扩充,它提供了多种方式来组织数据,如二进制、结构化文本等。
在许多情况下,数据类型并不能全面反映系统的需求,于是出现了抽象数据类型。
抽象数据类型描述一个计算机系统可以使用哪些数据类型,其中每种数据类型定义了一组操作。
从设计角度看,一个抽象数据类型是特定于某个具体硬件和软件平台的,但是这个类型被应用到任何一个硬件和软件平台上都将具有相同的含义。
抽象数据类型分类根据实现该抽象数据类型所用数据元素的类型,可以将抽象数据类型分为:基本数据类型:具有通用性的数据类型,其定义简单。
抽象数据类型中的所有操作,都可以使用基本数据类型中的成员来实现。
具体数据类型:不具有通用性,其定义较复杂。
从设计角度看,由于具体数据类型中的成员可能要受到硬件的制约,使得设计人员不得不考虑到硬件的具体类型。
抽象数据类型的主要特点: 1、在抽象数据类型定义中,不仅包括对象的引用和数据元素的数据值,还定义了操作和函数调用关系。
2、抽象数据类型中,常量成员只能按照预先确定的格式传送,字符串长度必须遵循预先确定的长度。
3、抽象数据类型的数据元素是按照不同规则组合在一起的。
4、抽象数据类型允许用户建立新的数据类型。
2、抽象数据类型的内部表示法:用对象的名称作为指针,与数据元素的数据类型相联系的一种表示方法。
有两种形式,一种是与其它数据类型相联系的形式;另一种是与标识符相联系的形式。
3、接口方法:指用来说明一个类能够用于实现另一个类的功能的类型信息。
接口方法的定义很简单,它总是指向对象的内部或者是指向一个成员函数。
4、基类:也叫做父类或者是上级类。
基类实现的是一个类的数据操作。
基类中定义的每个数据操作都要有目的地实现。
5、派生类:也叫子类或者是下级类。
派生类实现的是一个类的功能。
6、虚基类:也叫做基类或者是自身。
虚基类就是一个类,其中定义的每个数据操作都无需实现。
数据结构之串类型
数据结构之串类型 串的基本概念: 串(字符串):是零个或多个字符组成的有限序列。
记作: S=“a1a2a3…”,其中S是串名,ai(1≦i≦n)是单个,可以是字母、数字或其它字符。
串值:双引号括起来的字符序列是串值。
串长:串中所包含的字符个数称为该串的长度。
空串(空的字符串):长度为零的串称为空串,它不包含任何字符。
空格串(空⽩串):构成串的所有字符都是空格的串称为空⽩串。
注意:空串和空⽩串的不同,例如“ ”和“”分别表⽰长度为1的空⽩串和长度为0的空串。
⼦串(substring):串中任意个连续字符组成的⼦序列称为该串的⼦串,包含⼦串的串相应地称为主串。
⼦串的序号:将⼦串在主串中⾸次出现时的该⼦串的⾸字符对应在主串中的序号,称为⼦串在主串中的序号(或位置)。
特别地,空串是任意串的⼦串,任意串是其⾃⾝的⼦串。
串相等:如果两个串的串值相等(相同),称这两个串相等。
换⾔之,只有当两个串的长度相等,且各个对应位置的字符都相同时才相等。
通常在程序中使⽤的串可分为两种:串变量和串常量。
串的抽象数据类型定义: ADT String{ 数据对象:D = { ai|ai∈CharacterSet, i=1,2,…,n, n ≥0 } 数据关系:R = {<ai-1, ai>| ai-1, ai∈D, i=2,3,…,n } 基本操作: StrAssign(t , chars) 初始条件: chars是⼀个字符串常量。
操作结果:⽣成⼀个值为chars的串t 。
StrConcat(s, t) 初始条件:串s, t 已存在。
操作结果:将串t联结到串s后形成新串存放到s中。
StrLength(t) 初始条件:字符串t已存在。
操作结果:返回串t中的元素个数,称为串长。
SubString (s, pos, len, sub) 初始条件:串s, 已存在, 1≦pos≦StrLength(s)且 0≦len≦StrLength(s) –pos+1。
串的抽象数据类型的定义课件
字符串的替换
总结词
字符串的替换是指在一个字符串中查找并替换另一个字符串的操作。
详细描述
字符串的替换可以通过多种方式实现,例如在Python中,可以使用replace()方法来替换子串。该方 法将主串中所有出现的子串替换为指定的新字符串,并返回新的字符串。例如,将字符串 "HelloWorld"中的"World"替换为"Universe",可以得到新的字符串"HelloUniverse"。
子串的查找
总结词
子串的查找是指在一个字符串中查找另一个字符串是否存在,以及其出现的位置的操作。
详细描述
子串的查找可以通过多种方式实现,例如在Python中,可以使用find()方法来查找子串。该方法返回子串在主串 中第一次出现的位置的索引,如果找不到子串,则返回-1。例如,在字符串"HelloWorld"中查找子串"World", 可以得到其位置索引为6。
要点二
详细描述
解决字符串排序问题可以使用插入排序、选择排序或快速 排序等算法。插入排序通过将字符串拆分为若干子串,对 子串进行排序后拼接得到有序字符串。选择排序则是每次 从待排序的字符串中选择最小(或最大)的字符,将其放 到已排序部分的末尾。快速排序则是利用分治法,将字符 串拆分为更小的子串进行排序。
串的抽象数据类型的定义课件
目录
• 串的定义与特性 • 串的抽象数据类型 • 串的基本操作 • 串的存储结构 • 串的模式匹配算法 • 串的常见问题与解决方案
01
串的定义与特性
串的基本概念
串是由零个或多个字符组成的有限序列。
串中字符的顺序很重要,不同的顺序表示不同的 串。 空串是所有串的子串,即长度为0的串。
数据结构 串基本操作代码
数据结构串基本操作代码简介本文档介绍了数据结构中串的基本操作代码,包括串的定义、串的赋值、串的比较、串的连接、串的替换等。
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`或者循环遍历比较。
串的抽象数据类型的定义(精)
StrLength (S)
初始条件:串 S 存在。
操作结果:返回 S 的元素个数, 称为串的长度。
Concat (&T, S1, S2)
初始条件:串 S1 和 S2 存在。 操作结果:用 T 返回由 S1 和 S2 联接而成的新串。
StrDelete (&S, pos, len)
初始条件:串S存在
1≤pos≤StrLength(S)-len+1。
操作结果:从串S中删除第pos个字符
起长度为len的子串。
ClearString (&S) 初始条件:串S存在。 操作结果:将S清为空串。
思考题:
设S为一个长度为n的字符串, 其中的字符各不相同,则S中的互异 的非平凡子串(非空且不同于S本身) 的个数为_________
操作结果:用 V 替换主串 S 中出现 的所有与(模式串)T 相等的不重叠的子串。
例如:
假设 S = abcaabcaaabca bca bca bca, T = bca 若 V = x , 则经置换后得到 S = axaxaax
若 V = bc , 则经置换后得到 S = abcabcaabc
对于串的基本操作集可以有不同的定义 方法,在使用高级程序设计语言中的串类型 时,应以该语言的参考手册为准。 例:C++串库(string.h)中常见串函数: strlen(str) 求串长函数; strcpy(str1, str2) 串复制函数; strcat(str1, str2) 串联接函数; strcmp(str1, str2) 串比较函数; strchr(str, ch) 串定位函数; strrchr(str,ch) 串右定位函数;
串的抽象数据类型的定义
S = character
StrDelete (&S, pos, len) (删除)
初始条件:
串 S 存在,且 1≤pos≤StrLength(S)-len+1。(不是单独地对pos或者单独地对len限制,而是它们之间必须满足一
个关系,也就是互相限制)
4.1 串的抽象数据类型的定义
4.2 串的表示和实现
4.3 文本编辑 —串的应用举例
ADT String {
数据对象:
串是有限长的字符序 列,由一对双引号相 括,如: a string
D={ ai |ai∈CharacterSet, i=1,2,...,n, n≥0 }
数据关系:
R1={ < ai-1, ai > | ai-1, ai ∈D, i=2,...,n }
(求长度)
StrCompare (S, T)
初始条件:串 S 和 T 都存在。 操作结果:由串 S 小于或等于或大于串 T
分别返回小于或等于或大于 0 的值。
(串比较)
例如:StrCompare( data , state ) < 0 StrCompare( cat , case ) > 0
若主串 S 中存在和串 T 值相同的 子串,则返回它在主串 S 中第 pos 个字符之后第一次出现的位置; 否则函数值为0。
(定位函数)
“子串在主串中的位置”意指子串 中的第一个字符在主串中的“位序” 。
假设 S = abcaabcaaabc , T = bca Index(S, T, 1) = 2; Index(S, T, 3) = 6; Index(S, T, 8) = 0;
串的抽象数据类型
实习报告——“串的抽象数据类型”演示程序(一)、程序的功能和特点主要实现的功能:1.打印字符串;2.求当前串的实际长度;3.返回当前串的字符数组;4.在当前串中查找子字符串;5.取出当前从m开始n个字符组成的子串;6.判断当前串与对象串的大小关系;7.判断当前串是否为空串;8.取当前串的第i个字符;(二)、程序的算法设计“串的抽象数据类型”算法:1.【逻辑结构与存储结构设计】逻辑结构:线性结构存储结构:内存中连续的存储单元J A V A2.【基本操作设计】串的顺序存储结构是内存中用一段连续的存储单元存储字符序列所以可以通过数组实现3.【算法设计】在当前串中查找子字符串:(i、j为每个串元素在串中的索引位置)判断当前串与对象串的大小关系:While (串的索与对象引<当前串与对象串长度的最小的长度或遍历当前串元素!=对象串元素)返回当前串元素与对象串元素的差i=0 当前串长度与子串的差<0 返回-1 j=0 < 子串长度 i++ 否 是 是 依次比较串中元素与子串元素是否相等 是 否 j++否 j 为子串的长度 返回子串的开始位置4.【高级语言代码】//在当前串中查找子字符串public int Find(CString pat){//穷举法for(int i=0;i<curLen-pat.curLen;i++){int j=0;//从ch[i]与pat.ch比较while(j<pat.curLen)if(ch[i+j]==pat.ch[j])j++;else break;if(j==pat.curLen)return i+1;//pat扫描完,匹配成功,返回子串开始位置}return -1;//匹配失败}//取出当前串从m开始n个字符组成的子串public CString subString(int m,int n){//从串第m个位置起连续提取n个字符,形成子串返回if(m+n>curLen)//子串长度不合理n=curLen-m;char t[]=new char[n];//字符数组for(int i=0,j=m;i<n;i++,j++)t[i]=ch[j];//传送串数组CString temp=new CString(t);//构造方法2return temp;}//判断当前串与对象串other的大小关系public int CStringCmp(CString other){ intl=curLen>other.curLen?curLen:other.curLen;int i=0,j=0;while(i<l&&ch[i++]!=other.ch[j++]);return ch[i]-other.ch[j];}//判断当前串是否为空串boolean IsStrEmpty(){return curLen==0;}//将串other连接到当前串之后public void CStringApp(CString other){ int j=0,i=curLen;while(i<maxlen&&j<other.curLen)ch[i++]=other.ch[j++];curLen+=other.curLen;}//取当前串的第i个字符public char getchar(int i){if(i<curLen)return ch[i];elsereturn 0;}(三)、程序中类的设计“CString”类:1.【逻辑结构与存储结构】逻辑结构:线性结构2.【主要成员变量说明】int curLen;//串的实际长度char ch[]=new char[maxlen];//串的存储数组3.【主要成员方法说明】//打印字符串public void strPrint(){}//求当前串的实际长度public int Length(){}//返回当前串的字符数组public char[] getValue(){}//在当前串中查找子字符串public int Find(CString pat){}//取出当前串从m开始n个字符组成的子串public CString subString(int m,int n){ }//判断当前串与对象串other的大小关系public int CStringCmp(CString other){ }//判断当前串是否为空串boolean IsStrEmpty(){}//将串other连接到当前串之后public void CStringApp(CString other){ }//取当前串的第i个字符public char getchar(int i){}4.【高级语言代码】package study_2;//串的抽象数据类型import java.io.*;public class CString {final static int maxlen=128;int curLen;//串的实际长度char ch[]=new char[maxlen];//串的存储数组//构造方法1:从已有串复制public CString (CString other){curLen=other.curLen;for(int i=0;i<curLen;i++)ch[i]=other.ch[i];}//构造方法2:从已有字符数组复制public CString(char arrchar[]){curLen=arrchar.length;//数组长度for(int i=0;i<curLen;i++)ch[i]=arrchar[i];}//构造方法3:从键盘输入public CString(){System.out.println("输入若干字符后回车");try{BufferedReader br=new BufferedReader(new InputStreamReader(System.in));br.read(ch);}catch(IOException e){ }int l=0;while(ch[l]!=13)//回车结束l++;curLen=l;}//打印字符串public void strPrint(){for(int i=0;i<curLen;i++)System.out.print(ch[i]);System.out.println();}//求当前串的实际长度public int Length(){return curLen;}//返回当前串的字符数组public char[] getValue(){char tmp[]=new char[curLen];for(int i=0;i<curLen;i++){tmp[i]=ch[i];}return tmp;}//在当前串中查找子字符串public int Find(CString pat){//穷举法for(int i=0;i<curLen-pat.curLen;i++){ int j=0;//从ch[i]与pat.ch比较while(j<pat.curLen)if(ch[i+j]==pat.ch[j])j++;else break;if(j==pat.curLen)return i+1;//返回子串开始位置}return -1;//匹配失败}//取出当前串从m开始n个字符组成的子串public CString subString(int m,int n){ //从串第m个位置起连续提取n个字符,形成子串返回if(m+n>curLen)//子串长度不合理n=curLen-m;char t[]=new char[n];//字符数组for(int i=0,j=m;i<n;i++,j++)t[i]=ch[j];//传送串数组CString temp=new CString(t);//构造方法2return temp;}//判断当前串与对象串other的大小关系public int CStringCmp(CString other){int l=curLen>other.curLen?curLen:other.curLen;int i=0,j=0;while(i<l&&ch[i++]!=other.ch[j++]);return ch[i]-other.ch[j];}//判断当前串是否为空串boolean IsStrEmpty(){return curLen==0;}//将串other连接到当前串之后public void CStringApp(CString other){ int j=0,i=curLen;while(i<maxlen&&j<other.curLen)ch[i++]=other.ch[j++];curLen+=other.curLen;}//取当前串的第i个字符public char getchar(int i){if(i<curLen)return ch[i];elsereturn 0;}public static void main(String[] args) { CString s1=new CString();//构造方法3s1.strPrint();char tmp[]=s1.getValue();//字符数组CString s2=new CString(tmp);//构造方法2s2.strPrint();CString s3=new CString(tmp); //构造方法1s3.strPrint();CString sub1=new CString();System.out.println(s1.Find(sub1));s1.CStringApp(sub1);s1.strPrint();}}(四)、程序的输入输出和运行结果截屏。
抽象数据类型与面向对象概念
抽象数据类型与面向对象概念1. 引言抽象数据类型〔Abstract Data Type,简称ADT〕和面向对象〔Object-Oriented,简称OO〕是计算机科学中两个重要的概念。
它们都是用来描述数据和操作的方式。
本文将介绍什么是抽象数据类型和面向对象的概念,并探讨它们之间的关系。
2. 抽象数据类型〔ADT〕抽象数据类型是一种计算机科学中的概念,用来描述数据的表示和操作。
它将数据的表示细节隐藏起来,只暴露出一组操作,这样其他代码就可以通过这组操作来访问和修改数据,而不需要了解具体的实现细节。
常见的抽象数据类型包括栈、队列、链表、集合等。
它们都有自己的定义和一组操作,可以通过这些操作来访问和操作数据。
抽象数据类型的一个重要特点是封装〔Encapsulation〕。
封装指的是将数据和操作封装在一起,对外部只暴露一组操作接口。
封装可以隐藏数据的具体表示细节,提高代码的可读性和可维护性。
3. 面向对象〔OO〕面向对象是一种编程范式,它将数据和操作封装到一个类〔Class〕中。
类是面向对象的根本概念,它代表着一类对象的抽象。
对象是类的实例,具有自己的状态〔属性〕和行为〔方法〕。
面向对象的核心概念包括继承〔Inheritance〕、多态〔Polymorphism〕和封装〔Encapsulation〕。
继承指的是一个类可以从另一个类继承属性和方法。
子类可以继承父类的属性和方法,并且可以拥有自己的属性和方法。
继承可以提高代码的重用性和扩展性。
多态指的是同一个操作可以作用于不同的对象上,产生不同的结果。
这种特性可以增加代码的灵巧性,使得程序可以处理不同类型的对象。
封装在面向对象中的含义和抽象数据类型中的含义类似,指的是将数据和操作封装到一个类中,对外部只暴露一组操作接口。
4. 抽象数据类型与面向对象的关系抽象数据类型和面向对象都是用来描述数据和操作的方式,它们之间存在一些相似之处。
首先,抽象数据类型的封装特性和面向对象的封装概念是类似的。
串的抽象数据类型的定义.46页PPT
▪
26、要使整个人生都过得舒适、愉快,这是不可能的,因为人类必须具备一种能应付逆境的态度。——卢梭
▪
27、只有把抱怨环境的心情,化为上进的力量,才是成功的保证。——罗曼·罗兰
▪
28
16、自己选择的路、跪着也要把它走 完。 17、一般情况下)不想三年以后的事, 只想现 在的事 。现在 有成就 ,以后 才能更 辉煌。
18、敢于向黑暗宣战的人,心里必须 充满光 明。 19、学习的关键--重复。
20、懦弱的人只会裹足不前,莽撞的 人只能 引为烧 身,只 有真正 勇敢的 人才能 所向披 靡。
▪
29、勇猛、大胆和坚定的决心能够抵得上武器的精良。——达·芬奇
▪
30、意志是一个强壮的盲人,倚靠在明眼的跛子肩上。——叔本华
谢谢!
46
串的抽象数据类型的定义.
例如,可利用串比较、求串长和求子串等
操作实现定位函数 Index( S, T, pos )。 算法的基本思想为:
StrCompare(SubString(S, i, StrLength(T)), T )
?0
i
S串 pos
T串
n-m+1 T 串
int Index (String S, String T, int pos) {
4.1 串的抽象数据类型的定义 4.2 串的表示和实现 4.3 串的模式匹配算法
4.1 串的抽象数据类型的定义如下:
ADT String {
数据对象:
串是有限长的字符序 列,由一对双引号相 括,如: a string
D={ ai |ai∈CharacterSet, i=1,2,...,n, n≥0 }
4.2 串的表示和实现
在程序设计语言中,如果串只 是作为输入或输出的常量出现,则 只需存储此串的串值,即字符序列 即可。但在多数非数值处理的程序 中,串也以变量的形式出现。
一、串的定长顺序存储表示
二、串的堆分配存储表示 三、串的块链存储表示
一、串的定长顺序存储表示
#define MAXSTRLEN 255 // 用户可在255以内定义最大串长
} // while } // if return 0;
} // Index
// S中不存在与T相等的子串
又如串的置换函数:
pos sub T串 i pos = i+m
pos
n-pos+1
S串
V串
news 串
sub V串
void replace(String& S, String T, String V) { n=StrLength(S); m=StrLength(T); pos = 1; StrAssign(news, NullStr); i=1; while ( pos <= n-m+1 && i) { i=Index(S, T, pos); if (i!=0) { SubString(sub, S, pos, i-pos); // 不置换子串 Concat(news, news, sub); Concat(news, news, V); pos = i+m;
抽象数据类型
抽象数据类型抽象数据类型(ADT)是计算机科学中的一个重要概念,用于描述数据的逻辑结构和操作。
它将数据的表示和操作进行了抽象,使得数据的具体实现与其被使用的方式分离开来。
ADT通过定义数据的属性和操作,提供了一种将数据与其实现细节解耦的方式,使得程序开发更加灵活和可维护。
ADT的定义通常包括两个部分:数据的表示和操作。
数据的表示指的是数据的逻辑结构,即数据是如何组织和存储的。
操作指的是对数据的各种操作,包括创建、插入、删除、查找等等。
ADT的一个重要特点是封装性。
封装性指的是将数据的表示和操作封装在一起,外部程序只能通过指定的操作进行访问,而不能直接操作数据的表示。
这样可以确保数据的一致性,并隐藏实现的细节,提高了程序的安全性和可维护性。
常见的抽象数据类型包括数组、链表、栈、队列、堆、树、图等等。
每种抽象数据类型都有其特定的数据结构和对应的操作。
以数组为例,数组是一种线性表的抽象数据类型,在内存中连续存储相同类型的数据。
它的定义包括数据的表示和操作。
数据的表示是一个具有固定长度的连续存储空间,可以通过索引访问其中的元素。
操作包括创建数组、获取元素、修改元素等。
以栈为例,栈是一种特殊的线性表,只能在一端进行插入和删除操作。
栈的定义包括数据的表示和操作。
数据的表示通常使用数组或链表实现,操作包括入栈(push)和出栈(pop)等。
ADT在程序设计中具有重要的作用。
它提供了一种高级抽象的方式描述数据和操作,使得程序开发更加模块化和可重用。
例如,可以将ADT看作是一种接口,不同的数据结构可以实现相同的ADT,从而提供了一种替换的方式。
这样可以在不改变外部程序的情况下,改变内部数据结构的实现,从而提供了更多的实现选择和灵活性。
此外,ADT还可以帮助程序员更好地组织和管理代码。
通过将数据的表示和操作封装在一个逻辑单元中,可以提高代码的可读性和可维护性,并减少了代码的重复和冗余。
总结起来,抽象数据类型是一种将数据的表示和操作进行抽象的方式,在计算机科学中具有重要的作用。
4.3抽象数据类型
下面呈现的是一个简单的线性表抽象数据类型,其中定义了一组
最基本的操作。
ADT List: List(self) is_empty(self) len(self) prepend(self,elem) append(self,elem) insert(self,elem,i) del_first(self) del_last(self) del(self,i) search(self,elem) forall(self,op)
substr(self,a,b) #取得字符串中[a:b]的子串,左闭右开区间
match(self,string) #查找串string在本字符串中第一次出现的
位置
concat(self,string) #获得本字符串与另一个字符串string的拼
接串
subst(self,str1,str2) #获得将本字符串里的子串str1替换为
a=13 b=10 c=a+b print(c)
#语句1 #语句2 #语句3
整型变量
抽象是指抽取出事物具有的普遍性本质,是对具体事物的一个概括。 抽象是一种思考问题的方式,它隐藏了繁杂的细节,只保留实现目标 所必需的信息,实现抽象化后有利于对事物的抽象,便于实现功能、 提高模块独立性。 人们对已有数据类型进行抽象,就有了抽象数据类型。
字符串抽象数据类型的内部表现
抽象数据类型除了那些已经定义并实现的数据类型,还可以是
编程者在程序设计时使用的函数或者单独定义的数据类型等。
如使用Python的内建函数时,编程者只需考虑函数的功能是否满
足实际需要,再确保函数调用时的表达式是否符合函数构造的要
求,就可以使用此函数,而不需要知道该函数内部实现的任何具
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
======实习报告一“串的抽象数据类型”演示程序 ========(一)、程序的功能和特点1. 程序功能:建立存放字符串的数组,来存放串,并对以存放的串可以进行键盘录入,查找,统计和匹配,显示等功能。
2. 程序特点:采用java 面向对象语言,将串和对其的各种操作进行进行类的封装。
(二)、程序的算法设计 算法一:“在当前串中查找子字符串(模式匹配)”算法: 1.【逻辑结构与存储结构设计】 逻辑结构:线性结构。
存储结构:顺序存储结构。
这种存储方式可以直接得到串的长度:s.curlen+1。
如图所示。
串的顺序存储方式2.【基本操作设计】设主串s="ababcabcacbab ",模式t="abcac ",匹配过程如图所示。
3.【算法设计】0 1 2 3 4 5 6 7 8 9 10 ... MAXSIZE-1a b cdefghijk…第一趟 第二趟 第三趟 第四趟 第五趟 第六趟简单模式匹配的匹配过程s.curlens.data文字说明:(1).首先将字串的第一个字符和当前串的字符进行一一比对;(2).如果字串在当前串中第一个字符匹配成功,在进行第二个字符的匹配; (3).如果接下来字串中的第二个字符在当前串中接下来的一个字符匹配不成功,则匹配失败返回到(1),如果匹配成功则在进行接下来的字符匹配,如果其中有一次字符匹配不成功,则重新开始;(4).如果匹配成功返回字串出现的首地址。
且继续对当前串进行匹配到结束,有多少字串返回多少字串出现的首地址。
4. 【高级语言代码】//在当前串中查找子字符串(模式匹配) public int Find ( cString pat ){ //穷举的模式匹配for ( int i = 0; i <= curLen -pat.curLen ; i++ ){ //逐趟比较int j = 0; //从ch[i]与模式pat.ch 比较 while ( j < pat.curLen )if ( ch [i+j] == pat.ch [j] ) j++; else break ;if ( j == pat.curLen ) return i+1; //pat 扫描完, 匹配成功,返回子串开始位置 }return -1; //匹配失败 }算法二:“取出当前串从pos 开始len 个字符组成的子串”算法: 1.【逻辑结构与存储结构设计】 逻辑结构:线性结构。
存储结构:顺序存储结构。
这种存储方式可以直接得到串的长度:s.curlen+1。
如图所示。
串的顺序存储方式2.【基本操作设计】0 1 2 3 4 5 6 7 8 9 10 ... MAXSIZE-1a b cdefghijk…s.curlens.dataPos pos+len0 1 2 3 4 5 6.... .... MAXSIZE-1a b c d e f g ....创建char[len]数组0 1 2 .... Len-1c d e f g ...pos.dat3.【算法设计】文字说明:(1).首先创建字符数组char[len]。
(2).找到pos位置,既要取出子串的首地址;(3).再将当前串的元素从pos到pos+len依次存放到字符数组char[len]中;(4).返回取出的字符数组。
4.【高级语言代码】//取出当前串从pos开始len个字符组成的子串public cString subString( int pos, int len ){//从串中第 pos 个位置起连续提取 len 个字符//形成子串返回if ( pos+len > curLen ) //子串长度不合理len = curLen - pos;char t[]=new char[len]; //字符数组for ( int i = 0, j = pos; i < len; i++, j++ )t[i] = ch[j]; //传送串数组cString temp=new cString(t); //构造方法二return temp;}(三)、程序中类的设计“cString”类:1.【逻辑结构与存储结构】逻辑结构:线性结构。
存储结构:顺序存储结构。
串的顺序存储方式可以直接得到串的长度:s.curlen+1。
如图所示。
串的顺序存储方式示意图2.【主要成员变量说明】 主要成员变量有:maxLen ,int 类型变量,静态的最终变量,字符串允许的最大字符数。
curLen ; int 型变量,表示当前串的实际长度。
char ch []=new char [maxLen ];串的存储数组(一定是字符数组) 3.【主要成员方法说明】public cString (cString other):构造方法,参数为一个字符串,实现从已知串other 复制。
public cString ( char arrchar[]):构造方法,从已有字符数组中复制,参数为已知数组。
public cString( ):构造函数,无参,从键盘输入字符串。
public void strPrint():打印字符串。
public int Length ( ):求当前串的串的实际长度。
public char [] get_value ( ):返回当前串的字符数组。
public int Find ( cString pat ):在当前串中查找子字符串(模式匹配)。
public cString subString( int pos, int len ):取出当前串从pos 开始len个字符组成的子串。
public int cStringCmp ( cString other ):判当前串与对象串other 的大小关系。
boolean IsStrEmpty () :判当前串是否空串。
public void cStringApp (cString other)将串other 连接到当前串之后。
public char getChar( int i )取当前串的第 i 个字符。
4.【高级语言代码】 //定义“字符串”类 class cString {final static int maxLen = 128; int curLen ; //串的实际长度char ch []=new char [maxLen ]; //串的存储数组(一定是字符数组) //构造方法一:从已有串other 复制 public cString (cString other) { curLen =other.curLen ;for (int i=0;i<curLen ;i++) ch [i]=other.ch [i]; }//构造方法二:从已有字符数组复制0 1 2 3 4 5 6 7 8 9 10 ... MAXSIZE-1abcdefghijk…s.curlen n s.datapublic cString ( char arrchar[]) {curLen=arrchar.length; //数组长度for(int i=0;i<curLen;i++)ch[i]=arrchar[i];}//构造方法三:从键盘输入public cString( ) {System.out.println("输入若干字符后,回车。
");try {BufferedReader br=new BufferedReader(new InputStreamReader(System.in));br.read(ch);} catch(IOException e){}int l=0;while(ch[l]!=13) l++; //回车结束curLen=l; //串的实际长度}//打印串public void strPrint() {for(int i=0;i<curLen;i++)System.out.print(ch[i]);System.out.println();}//求当前串的实际长度public int Length ( ) { return curLen; }//返回当前串的字符数组public char[] get_value ( ){char tmp[]=new char[curLen];for(int i=0;i<curLen;i++)tmp[i]=ch[i];return tmp;}//在当前串中查找子字符串(模式匹配)public int Find ( cString pat ){//穷举的模式匹配for ( int i = 0; i <= curLen-pat.curLen; i++ ){ //逐趟比较int j = 0; //从ch[i]与模式pat.ch比较while ( j < pat.curLen )if ( ch[i+j] == pat.ch[j] ) j++;else break;if ( j == pat.curLen ) return i+1;//pat扫描完, 匹配成功,返回子串开始位置}return -1; //匹配失败}//取出当前串从pos开始len个字符组成的子串public cString subString( int pos, int len ){//从串中第 pos 个位置起连续提取 len 个字符//形成子串返回if ( pos+len > curLen ) //子串长度不合理len = curLen - pos;char t[]=new char[len]; //字符数组for ( int i = 0, j = pos; i < len; i++, j++ )t[i] = ch[j]; //传送串数组cString temp=new cString(t); //构造方法二return temp;}//判当前串与对象串other的大小关系public int cStringCmp ( cString other ){int l=curLen>other.curLen ? curLen : other.curLen;int i=0,j=0;while(i<l&&ch[i++]!=other.ch[j++]);return ch[i]-other.ch[j];}//判当前串是否空串boolean IsStrEmpty () {return curLen == 0;}//将串other连接到当前串之后public void cStringApp (cString other) {int j=0,i=curLen;while(i<maxLen&&j<other.curLen)ch[i++]=other.ch[j++];curLen+=other.curLen;}//取当前串的第 i 个字符public char getChar( int i ) {if(i<curLen)return ch[i];elsereturn 0;}//主方法public static void main(String args[]){cString s1=new cString(); //构造方法三s1.strPrint();char tmp[]=s1.get_value(); //字符数组cString s2=new cString(tmp); //构造方法二s2.strPrint();cString s3=new cString(tmp); //构造方法一s3.strPrint();cString sub1=new cString();System.out.println(s1.Find(sub1));s1.cStringApp(sub1);s1.strPrint();}} //定义“字符串”类cString结束(四)、程序的输入输出和运行结果截屏程序运行结果截屏:。