计算机数据结构第四章串
严蔚敏数据结构-第四章 串
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的子串
数据结构第四章 串
数据结构第四章串在数据结构的世界里，串是一种非常基础且重要的结构。
它看似简单，却在很多实际的程序设计和应用中发挥着关键作用。
串，简单来说，就是由零个或多个字符组成的有限序列。
这就好比我们日常生活中的一句话、一段文字或者一个密码。
从存储方式上来看，串可以采用顺序存储和链式存储两种方式。
顺序存储就像是把一串珠子穿在一根线上，珠子依次排列，位置固定。
在计算机中，我们可以用一个连续的数组来存储串中的字符。
这种方式简单直观，访问速度快，但存在着一些局限性。
比如说，如果我们事先不知道串的长度，可能会造成存储空间的浪费或者不足。
相比之下，链式存储则更加灵活。
它就像把珠子用链条串起来，每个珠子（也就是字符）都有一个指针指向下一个珠子。
这样，即使在插入或删除字符时，也不需要像顺序存储那样进行大量的数据移动。
但是，链式存储的缺点是访问速度相对较慢，因为需要通过指针依次查找。
接下来，让我们看看串的一些基本操作。
串的比较是经常会用到的操作。
比较两个串的大小，不能像比较数字那样简单地直接比较，而是要从串的第一个字符开始，逐个字符进行比较。
如果在某个位置上的字符不同，那么 ASCII 码值大的那个串就更大；如果前面的字符都相同，但是一个串先结束了，那么长度短的串就更小。
串的连接也是常见的操作。
想象一下把两段绳子接在一起，就形成了一个更长的绳子。
串的连接也是类似的道理，把两个串首尾相连，形成一个新的串。
但在实际操作中，要注意存储空间的分配，确保有足够的空间来容纳连接后的串。
还有串的子串操作。
比如说，从一篇文章中截取一段文字，这就是获取一个子串。
在程序中，我们需要明确指定子串的起始位置和长度，才能准确地获取到所需的部分。
串的模式匹配更是一个重要的应用。
这就像是在一篇长篇小说中寻找特定的关键词或者短语。
最常见的模式匹配算法有朴素模式匹配算法和 KMP 算法。
朴素模式匹配算法比较直接，就是从主串的开头逐个字符与模式串进行匹配。
而 KMP 算法则通过对模式串进行预处理，利用已经匹配的部分信息，减少不必要的比较，从而提高匹配的效率。
数据结构——第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.1 4.2
串类型的定义 串的表示和实现
4.2.1 定长顺序存储表示 4.2.2 堆分配存储表示 4.2.3 串的块链存储表示
第四章 串
4.1 串类型的定义
一、串的基本概念 定义：字符串是 n ( 0 ) 个字符的有限序列
记作 S = “c1c2c3…cn”
其中:
S 是串名字 “c1c2c3…cn”是串值 ci 是串中字符 n 是串的长度
4.1 串类型的定义
一、串的基本概念
串中任意个连续字符组成的子序列称为该串的
子串，包含子串的串相应地称为主串。
子串在主串中首次出现时的该子串的首字符 对应的主串中的序号，定义为子串在主串中的
序号（或位置）
例如，设A和B分别为 A=“This is a string” B=“is”
4.1 串类型的定义
提取子串的算法示例
pos = 3, len = 3 infini ty
pos = 6, len = 4 infini ty
fin
len S[0]-pos+1
超出 len > S[0]-pos+1
合法参数条件: Pos>=0, Pos<=S[0], Len>=0
len <=S[0]-pos+1
求子串的过程即为复制字符序列的过程，将串S中的 第pos个字符开始长度为len的字符复制到串T中。
1、串的插入的动态实现过程 s.length+ t.length
SA
l o v el y
pos Tl o
t.length
vely
g irl!
t.length
1、串的插入的动态实现过程 s.length+ t.length
数据结构第4章 串
/*若串s和t相等则返回0；若s>t则返回正数；若s<t则返 回负数*/
{ int i;
for (i=0;i<s.len&&i<t.len;i++)
if (s.ch[i]!=t.ch[i]) return(s.ch[i] - t.ch[i]);
初 始 条 件 : 串 S 存 在 ,1≤pos≤StrLength(S) 且 1≤len≤StrLength(S)-pos+1
操作结果:用Sub返回串S的第pos个字符起长度为len的子串
返回主目录
（11）StrIndex(S,T,pos)
初始条件: 串S和T存在,T是非空串, 1≤pos≤StrLength(S)
return(s.len); }
返回主目录
（7）清空函数
StrClear(SString *s) /*将串s置为空串*/ {
s->len=0; }
返回主目录
（8）连接函数
(1) 连接后串长≤MAXLEN，则直接将B加在A的 后面。 (2) 连接后串长>MAXLEN且LA<MAXLEN，则B 会有部分字符被舍弃。 (3) 连接后串长>MAXLEN且LA=MAXLEN，则B 的全部字符被舍弃（不需连接）。
for (i=s->len + t.len-1;i>=t.len + pos;i--)
s->ch[i]=s->ch[i-t.len];
for (i=0;i<t.len;i++) s->ch[i+pos]=t.ch[i];
s->len=s->len+t.len;
数据结构--第四章 串
则:串s3是s1的子串， s1是s3的主串；
串s2不是s1的子串
5
串的概念
串的位置：字符在序列中的序号为 该字符在串中的位置。子串在主 串中的位置则以子串的第一个字 符在主串中的位置来表示。特别 地，空串是任意串的子串，任意 串是其自身的子串。 例如： s1=’I have a dog’; s3=’dog’ 则:子串s3在s1中的位置为匹配（求子串位置） 第一趟：
i=1
a b a b c a b c a c b a b
J=1
a b c
31
串基本操作的实现 —— 串的模式匹配（求子串位置） 第一趟：
i=3
a b a b c a b c a c b a b
J=3
a b c
32
串基本操作的实现 —— 串的模式匹配（求子串位置） 第二趟：
D A T A S T R U C T U R E
D U R
A S C E
T T T
A R U
19
串的存储结构——动态存储结构
串的动态存储方式采用链式存储结构 和堆存储结构两种形式： （一） （二） 块链存储 堆结构
20
串的动态存储结构 ——块链存储的引入
用单链表存放串，每个结点仅存储一个字符， 每个结点的指针域所占空间比字符域所占空间 要大得多。定义如下： typedef struct node{ char ch; struct node *next;
9
串的基本操作定义
⑵ 判等函数：Equal(s,t)
若s和t相等， 则返回函数值(即运算结 果)1， 否则返回函数值 0。s和t可以是 非空串，也可以是空串。 例如， 执行Equal (a,b) 后， 值为0。 执行Equal (‘abc’,‘abc’) 后， 值为1。
数据结构（C语言版）第4章串
第4章串串：限定数据元素类型的线性表。
1 逻辑结构1.1 定义位串：数据元素属于{0,1}ASCII码串: 数据元素属于ASCII码字符集。
数字串：数据元素属于整数集合2 顺序串///////////////////////////////// // 项目路径：7动态顺序串/////////////////////////////////2.2 构造/析构（测试函数Test1）template <class T>String<T>:: String( ){ m_Data=NULL; m_Size=m_Length=0; }template <class T>String<T>::String(T a[], int n){ m_Size = m_Length = n;m_Data = new T[m_Size];if(!m_Data) throw "内存不够，上溢";for(int i=0; i<m_Length; i++)m_Data[i]=a[i];}template <class T>String<T>::String(String &s) // 拷贝构造函数{ m_Size = m_Length = s.m_Length;m_Data = new T[m_Size];if(!m_Data) throw "内存不够，上溢";for(int i=0; i<m_Length; i++)m_Data[i]=s.m_Data[i];}template <class T>String<T>:: ~String( ){ delete []m_Data; }2.3 比较（测试函数Test2）// 重载<template <class T>bool String<T>::operator<(String &s){ for(int i=0; i<m_Length && i<s.m_Length; i++) { if(m_Data[i]<s.m_Data[i]) return true;if(m_Data[i]>s.m_Data[i]) return false;}if(m_Length<s.m_Length) return true;return false;}// 重载==template <class T>bool String<T>::operator==(String &s){ for(int i=0; i<m_Length && i<s.m_Length; i++) if(m_Data[i]!=s.m_Data[i]) return false; if(m_Length==s.m_Length) return true;return false;}2.4 取子串、连接（测试函数Test3）// 取子串template <class T>String<T> String<T>::Substr(int pos,int len) { if(pos+len>m_Length) // 预防子串长度越界len=m_Length-pos;String<T> s;s.m_Length=s.m_Size=len;s.m_Data = new T[s.m_Size];if(!s.m_Data) throw "内存不够，上溢";for(int i=0; i<len; i++)s.m_Data[i]=m_Data[pos+i];return s;}// 连接stemplate <class T>void String<T>::Concat(String s){ if(m_Length+s.m_Length > m_Size) // 空间不够ReNew(m_Length+s.m_Length);for(int i=0; i<s.m_Length; i++)m_Data[m_Length+i] = s.m_Data[i];m_Length += s.m_Length;}// 重新分配串的存储空间template <class T>void String<T>::ReNew(int size){ T *p=new T[size]; // 重新申请空间 m_Size=size;for(int i=0; i<m_Length; i++) // 数据迁移p[i]=m_Data[i];delete []m_Data; // 释放原串空间 m_Data = p;}2.5 插入、删除（测试函数Test4）// 第i个位置上插入stemplate <class T>void String<T>::Insert(int pos, String s){ if(m_Length+s.m_Length > m_Size) // 空间不够 ReNew(m_Length+s.m_Length);for(int i=m_Length-1; i>=pos; i--) // 向后移位 m_Data[i+s.m_Length] = m_Data[i];for(i=0; i<s.m_Length; i++)m_Data[pos+i] = s.m_Data[i];m_Length += s.m_Length;}// 删除子串template <class T>void String<T>::Delete(int pos,int len){ for(int i=pos+len; i<m_Length; i++) // 向前移位 m_Data[i-len] = m_Data[i];m_Length -= len;}2.6 顺序串的评价优点：访问子串方便，缺点：空间大小不灵活，插入、删除费时。
数据结构-第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)代表单个字符，可以是字母、 数字或其它字符(包括空白符)。 串值：双引号括起来的字符序列。双引号不是 串的内容，只起标识作用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
2、串的抽象数据类型定义
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) 初始条件：chars是字符串常量。 操作结果：生成一个其值等于chars的串T。
2.求子串SubString(&Sub,S,pos,len)
初始条件：串S存在， 1≤pos≤StrLength(S)
且 0≤len≤StrLength(S)-pos+1 。 操作结果：用Sub返回串S的第pos个字
符起长度为len的子串。 算法思想：求子串的过程即为复制字符
序列的过程，将串S中从第pos个字符 开始长度为len的字符序列复制到串 Sub中。
基本运算实现
1.串联接Concat（&T，S1，S2）
S1[0]
S2[0]
S1
S2
T
T[0]
MAXSTRLEN
( a ) S1[0]+S2[0]≤MAXSTRLEN
S1[0]
S1
S2[0]
S2
T
S2中被截去的部分
T[0]
MAXSTRLEN
( b ) S1[0]<MAXSTRLEN 而S1[0] +S2[0]>MAXSTRLEN
若S=T，则返回值=0；若S<T，则返回值<0
int comparestr(SString S,SString T) {
int i; for (i=1;i<=s[0]&&i<=t[0];i++)
if(s[i]!=t[i]) return (s[i]-t[i]); return (s[0]-t[0]); }
子串，串中任意个连续的字符组成的子序列称为该 串的子串。
主串，包含子串的串。
位置,字符在序列中的序号为该字符在串中的位置.
例:4个串
a='BEI',b='JING', c='BEIJING',d='BEI JING'
两个串相等,当且仅当这两个串的值相等.
空格串 (blank string,请注意此处不是空串）， 由一个或多个空格组成的串''.
StrCompare(S,T) 初始条件：串S和串T存在。 操作结果：若S>T,则返回值>0;若S=T,则返回值=0; 若S<T,则返回值<0。
StrLength(S) 初始条件：串S存在。 操作结果：返回值S的元素个数，称为串的长度。
Concat（&T，S1，S2） 初始条件：串S1和S2存在。 操作结果：用T返回S1和S2联接成的新串。
4.2.1 定长顺序存储表示
思想: 用一组地址连续的存储单元存储串值的字 符序列
#define MAXSTRLEN 255//用户可在255以内定义最大串
长
typedef unsigned char SString[MAXSTRLEN+1]; //0号单元存放串的长度 串的实际长度可在这预定义长度的范围内随意， 超过预定义长度的串值则被舍去，称为“截断”。
第4章 串
4.1 串类型的定义 4.2 串的表示和实现 4.3 模式匹配算法 4.4 串操作应用举例
4.1 串类型的定义
1、名词术语
串（String)(或字符串），是由零个或多个字符组成 的有限序列。一般记做s=‘a1a2…an’(n>=0)
串的长度，串中字符的数目n。
空串（Null string),零个字符的串，它的长度为零。
SubString(&Sub,S,pos,len) 初始条件：串S存在，1≤pos≤StrLength(S)且0≤ len ≤StrLength(S)-pos+1 。 操作结果：用Sub返回串S的第pos个字符起长度为 len的子串。
……
} ADT String
4.2 串的表示和实现
4.2.1 定长顺序存储表示 4.2.2 堆分配存储表示 4.2.3 块链存储表示
算法实现
Status SubString(SString &Sub,SString S,int pos,int len)
{ if(pos<1 || pos>S[0] || len<0 || len>S[0]-pos+1) return ERROR; Sub[1..len]=S[pos..pos+len-1]; Sub[0]=len; return OK; }
定长顺序存储结构总结
1.采用此存储结构，实现串操作的原操作 为“字符序列的复制”；操作的时间复 杂度基于复制的字符序列的长度
2.如果在操作中出现串值序列的长度超过 上界MAXSTRLEN时,约定用截尾法处理. 克服这点惟有不限定串的最大长度,即动 态分配串值的存储空间
思考练习：比较二个串，若S>T,则返回值>0;
4.2.2 堆分配存储表示
思想: 仍用一组地址连续的存储单元存储串值的字符序 列,但它们的存储空间是在程序执行过程中动态分配而 得。串的存储空间仍由malloc()函数来分配。 类型定义：
typedef struct{ char *ch; int length;
}HString;
S1[0]
S2[0]
S1
S2
T
S2串全部被截去
T[0]
MAXSTRLEN
( c ) S1[0]=MAXSTRLEN
算法实现
Status Concat(SString &T,SString S1,SString S2){ if (S1[0]+S2[0]<=MAXSTRLEN){ // 未截断
T[1..S1[0]]=S1[1..S1[0]]; T[S1[0]+1..S1[0]+S2[0]]=S2[1..S2[0]]; T[0]=S1[0]+S2[0]; uncut =TRUE;} else if(S1[0]<MAXSTRLEN){ // 截断 T[1..S1[0]]=S1[1..S1[0]]; T[S1[0]+1..MAXSTRLEN]=S2[1..MAXSTRLEN-S1[0]]; T[0]= MAXSTRLEN; uncut =FALSE;} else{ // 截断(仅取S1) T[0 ..MAXSTRLEN]= S1[0 ..MAXSTRLEN]; uncut =FALSE;} return uncut;}