第四章 字符串
严蔚敏数据结构-第四章 串
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的子串
第四章串A
（1）初始化ClearString（S）：初始化串S(串S存 在，将S清为空串)。 （2）StrAssign（&T，char）：生成串。
（3）StrCopy(&T，S)：串复制(将串S复制到串T)。5
第4 章 串
（4）Concat（&T，s1，s2）:串联接(用T返回S1,S2 联接而成的新串)。 （5）求串长StrLength（S）：返回S串的元素个数， 即S串的长度。 （6）串比较StrCompare（S，T） （7）求子串SubString（&Sub，S，pos，len）： 返回s串的第pos个字符起始的长度为len的子串。 （8）插入运算SetInsert（&S，T，pos）：把串t的 值插入到串s的第pos个字符之后。 （9）删除运算StrDelte（&S，pos，len）：将串s
可能出现如下三种情况： a. S1长度+S2长度<=T长度，则S1+S2可以完整放入T中； b. S1长度+S2长度>T长度，则S1完整放入，S2放入一部 分； c. S1长度=T长度，则S1完整放入，S2不能放入。 注意：各串长度数据放入该串的 0 单中。（如图4.1示）
11
第4 章 串
两串联结的C语言程序 (算法4.2)
{ int i; orderstribg *r ;
printf(“ r1=%s,r2=%s\n”,r1.vec,r2.vec);
if (r1.len+r2.len>m0) printf(“上溢出\n”) ; /* 若两串长度之和大于m0，则进行溢出处理*/
12
第4 章 串
else { for (i=0; i<r1.len; i++) r.vec[i]=r1.vec[i]; for (i=0; i<r2.len;i++) /*将串r2传r */ r.vec[r1.len+ i ]= r2.vec[i]; r.vec[r1.len+ i ]=“\0” ; /*最后一个位置赋给\0 */ r.len=r1.len+r2.len; } return(r); } /*r串长度等于两串长度之和*/ /*将串r1传给r */
第4章 字符串v
空串： 空串： 长度为0的字符串 的字符串； 长度为 的字符串； 空格串： 空格串： 由空格字符组成的字符串，长度>1 由空格字符组成的字符串，长度 主串： 主串： 包含该子串的字符串; 包含该子串的字符串; 字符的位置： 字符的位置： 从1开始 开始 子串的位置： 子串的位置： 该子串第一个字符的位置
定长顺序存储标识串的实际长度时可有三种方式： 定长顺序存储标识串的实际长度时可有三种方式：
（1）用一个指针指向最后一个字符，串描述类似顺序表 用一个指针指向最后一个字符， 用一个指针指向最后一个字符 #define MAXSIZE 256 typedef struct { char data[MAXSIZE]; int curlen; }SeqString; 定义一个串变量：SeqString s; 定义一个串变量
1.串的 定长 顺序存储 串的（定长 串的 定长）顺序存储
（定长 顺序存储结构类似于C语言的字符数组，以一 定长）顺序存储结构类似于 语言的字符数组， 定长 顺序存储结构类似于 语言的字符数组 组地址连续的存储单元存放串值中的字符序列， 组地址连续的存储单元存放串值中的字符序列，定长即是预 先为每一个串变量分配一个固定长度的存储区，例如： 先为每一个串变量分配一个固定长度的存储区，例如： #define MAXSIZE 256 char s[MAXSIZE] 那么，串的最大长度就不能超过 那么，串的最大长度就不能超过256。 。
第4章 串 章
4.1 字符串的基本概念
4. 2 串的存储结构
4.3 模式匹配
（1） 串的基本概念
串(string)是由零个或多个任意字符组成的字符序列， )是由零个或多个任意字符组成的字符序列， 又称为字符串( 又称为字符串(character string)，一般记为: ) 一般记为: s=〝a1 a2 a3 … an〞
（个人收集学习笔记）4字符串处理与正则表达式
（个人收集学习笔记）4字符串处理与正则表达式第四章字符串处理与正则表达式一、字符串处理介绍1、如果字符串处理函数和正则表达式都可以实现字符串操作，建议使用字符串处理函数，因为效率高。
2、因为PHP 是弱类型语言，所以其他类型的数据一般都可以直接应用于字符串操作函数里，而自动转换成字符串类型进行处理。
3、还可以将字符串视为数组，或当作字符集合来看待。
$str[0]$str{0}二、常用的字符串输出函数1、echo()函数：使用它的效率要比其他字符串输出函数高。
2、print()函数：功能和echo()一样，但它有返回值，成功返回1，不成功返回0。
3、die()函数：exit()函数的别名。
1）参数如果是字符串，则该函数会在退出前输出它。
2）如果参数是一个整数，这个值会被用做退出状态。
值在0-254之间，退出状态255由PHP 保留，不会使用。
状态0用于成功终止程序。
4、printf():用于输出格式化字符串。
1）例子：printf(“%s age is $d”,$str,$num);2）%d ：带符号十进制数%u ：无符号十进制数%f ：浮点数%s ：字符串%b ：二进制数%c ：依照ASCII 值的字符%%：返回百分比符号%o ：八进制数%x ：十六进制数（小写字母）%X ：十六进制数（大写字母）3)如果%符号多于arg 参数，则必须使用占位符。
占位符被插入到%符号之后，由数字和\$组成。
如：printf(“The %2\$s book contains %1\$d pages.That’s a nice %2\$s full of %1\$d pages”,$num,$str);%2\$s 代表$str 。
5、sprintf()函数：用法和printf()一样，但它不是输出字符串，而是把格式化的字符串以返回值的形式写入到一个变量中。
三、常用的字符串格式化函数字符串的格式化就是将字符串处理为某种特定的格式。
《数据结构与算法》第四章-学习指导材料
《数据结构与算法》第四章串知识点及例题精选串（即字符串）是一种特殊的线性表，它的数据元素仅由一个字符组成。
4.1 串及其基本运算4.1.1 串的基本概念１．串的定义串是由零个或多个任意字符组成的字符序列。
一般记作：s=＂s1 s2 … s n＂＂其中s 是串名；在本书中，用双引号作为串的定界符，引号引起来的字符序列为串值，引号本身不属于串的内容；a i(1<=i<=n)是一个任意字符，它称为串的元素，是构成串的基本单位，i是它在整个串中的序号; n为串的长度，表示串中所包含的字符个数，当n=0时，称为空串，通常记为Ф。
２．几个术语子串与主串：串中任意连续的字符组成的子序列称为该串的子串。
包含子串的串相应地称为主串。
子串的位置：子串的第一个字符在主串中的序号称为子串的位置。
串相等：称两个串是相等的，是指两个串的长度相等且对应字符都相等。
4.2 串的定长顺序存储及基本运算因为串是数据元素类型为字符型的线性表，所以线性表的存储方式仍适用于串，也因为字符的特殊性和字符串经常作为一个整体来处理的特点，串在存储时还有一些与一般线性表不同之处。
4.2.1 串的定长顺序存储类似于顺序表，用一组地址连续的存储单元存储串值中的字符序列，所谓定长是指按预定义的大小，为每一个串变量分配一个固定长度的存储区，如：#define MAXSIZE 256char s[MAXSIZE];则串的最大长度不能超过256。
如何标识实际长度？1. 类似顺序表，用一个指针来指向最后一个字符，这样表示的串描述如下：typedef struct{ char data[MAXSIZE];int curlen;} SeqString;定义一个串变量：SeqString s;这种存储方式可以直接得到串的长度：s.curlen+1。
如图4.1所示。
s.dataMAXSIZE-1图4.1 串的顺序存储方式12. 在串尾存储一个不会在串中出现的特殊字符作为串的终结符，以此表示串的结尾。
第四章 串图文
在上述串的抽象数据类型定义的13种操作中,串 赋值StrAssign、串复制Strcopy、串比较 StrCompare、求串长StrLength、串联接Concat以 及求子串SubString等六种操作构成串类型的最小 操作子集。即：这些操作不可能利用其它串操作 来实现,而其它串操作（除串清除ClearString和 串销毁DestroyString外）如定位函数Index( S, T, pos )可在这个最小操作子集上实现如p72。
例如：C语言函数库中提供下列串处理函数：
gets(str) 输入一个串； puts(str) 输出一个串； strcat(str1, str2) 串联接函数； strcpy(str1, str2, k) 串复制函数； strcmp(str1, str2) 串比较函数； strlen(str) 求串长函数；
子串的定位
Replace (&S, T, V) 串的置换 StrInsert (&S, pos, T) 串的插入
StrDelete (&S, pos, len) 串的删除
} ADT String
StrAssign (&T, chars)
（串的赋值）
初始条件：chars 是字符串常量。
操作结果：把 chars中的字符串 常量 赋给 T。
StrDelete (&S, pos, len)
初始条件：串S存在
1≤pos≤StrLength(S)-len+1。
操作结果：从串S中删除第pos个字符 起长度为len的子串。
ClearString (&S)
初始条件：串S存在。 操作结果：将S清为空串。
串的基本操作集可以有不同的定义方法， 在使用高级程序设计语言中的串类型时，以该 种语言的参考手册为准。
第四章 串
– 例如
• 主串S = • 子串T = CD • 则index(S,T)，返回子串T在S中，第一次出现的位置3
19
串的模式匹配
Brute-Force算法基本思想： • 从目标串s 的第一个字符起和模式串t的第一个字符进行比较 • 若相等，则继续逐个比较后续字符，否则从串s 的第二个字 符起再重新和串t进行比较。 • 依此类推，直至串t 中的每个字符依次和串s的一个连续的字 符序列相等，则称模式匹配成功，此时串t的第一个字符在串s 中的位置就是t 在s中的位置，否则模式匹配不成功。
两式联立可得：“T0…Tk-1”= “Tj-k…Tj-1”
注意：j为当前已知的失配位置，我们的目标是计算新起点k。式中仅剩 一个未知数k，理论上已可解！
奇妙的结果：k仅与模式串T有关！
27
新起点k怎么求？
根据模式串T的规律：“T0…Tk-1”=“Tj-k …Tj-1” 由当前失配位置j(已知)，归纳计算新起点k的表达式。
j=next[j]的位置(即模式串继续向右移动)，再比较 si 和 tj 。
依次类推，直到下列两种情况之一： 1)j退回到某个j=next[j]时有 si = tj，则指针各增1，继续匹配； 2)j退回至j=0，此时令指针各增1，即下一次比较 si+1和 t0 。
30
串的模式匹配：KMP算法
• 模式串的next函数
6
串的基本概念
4.两个字符串相等的充分必要条件为两个字符串的长度相等，并 且对应位置上的字符相等。
例如：‘abcd’ ≠ ‘bacd’ ‘abcd’ = ‘abcd’
7
串的基本操作
1.给串变量赋值 ASSIGN(S1,S2)
数据结构第四章：串
例2、串的定位 、串的定位index(s,t,pos)
在主串s中取从第 个字符起、 相等的子串和T比较 在主串 中取从第pos个字符起、长度和串 相等的子串和 比较，若 中取从第 个字符起 长度和串T相等的子串和 比较， 相等，则求得函数值为i，否则值增1直至 中不存在和串T相等的子串 直至S中不存在和串 相等，则求得函数值为 ，否则值增 直至 中不存在和串 相等的子串 为止。 为止。
}
4.2 串的表示和实现
首先强调：串与线性表的运算有所不同，是以“串的整体” 首先强调：串与线性表的运算有所不同，是以“串的整体”作 为操作对象，例如查找某子串， 为操作对象，例如查找某子串，在主串某位置上插入一个子串 等。 串有三种机内表示方法： 串有三种机内表示方法：
定长顺序存储表示
顺序 存储 ——用一组地址连续的存储单元存储串值的字 用一组地址连续的存储单元存储串值的字 符序列， 静态存储方式 方式。 符序列，属静态存储方式。
4.1 串类型的定义 4.2 串的表示和实现
4.1 串的类型定义
4.1.1串的定义
定义：串(string)是由零个或多个任意字符组成的字 符序列，是数据元素为单个字符的特殊线性表。 的特殊线性表。 是数据元素为单个字符的特殊线性表 记为：an”
(n≥0 )
第4章 串（String） 章 ）
本章主题：串的各种基本运算及其实现 本章主题： 教学目的：了解数据结构的基本概念， 教学目的：了解数据结构的基本概念，理解常用术语 教学重点： 教学重点： 掌握串的基本概念及其基本运算 掌握串的存储结构 主要内容： 主要内容： 1.串的基本概念 2.串的存储结构 2.串的存储结构 3.串的基本运算及其实现 3.串的基本运算及其实现
串其中0<=pos<=strlen(s)-1,且数组 且数组sub至少可容纳 至少可容纳len+1个字符。*/ 个字符。 串其中 且数组 至少可容纳 个字符
第4章：数组和字符串
4.1.1一维数组
2． 创建一维数组
创建一维数组就是为数组分配存储空间，需指定数组长度。 数组创建后，数组名就标识用于存储数组元素的存储空间(引用)。 创建一维数组的３种方法：
（1） 先声明后创建
数组元素类型 数组名[]; 数组名 ＝ new 数组元素类型[元素个数] ； 如：int intArray []; intArray = new int[5];4.2.3 字符串基本操作
字符串比较的注意事项：
表达式 str1.equals(str2)与表达式 str1==str2 的差异 在于：
• 前者表示所引用的两个字符串的内容是否相同， • 后者表示str1 与 str2是否引用同一个对象。 【实战编程技巧：如何避免潜在的空指针异常】
练习题
4.1 数组
4.2 字符串
4.1 数组
数组是将一组相同类型的数据顺序存储，组成的一 种复合数据类型。 数组的特点：
数组中的所有元素的数据类型相同。 数组中的元素连续顺序存储。 数组中每个元素按存储顺序对应一个下标，下标从０开始顺序编号 ，引用数组元素通过数组名和它的下标确定。 数组有一维数组和多维数组之分，数组元素的下标个数确定数组的 维数。
练习题
【真题练习】设有数组a和b的定义如下： int[]a={1,2,3}; int[]b={4,5,6} …… 执行以下代码“a=b；”,除了完成赋值操作之外，引起 系统额外要做的工作是_________。
《Python编程案例教程》课件 第4章 字符串的使用
通用序列操作
简单地说，序列是一块用来存放多个值的连续内存空间。 Python中常用的序列结构有字符串、列表、元组等。 所有序列类型都可以进行某些特定的操作。这些操作包括 索引 分片 加 乘 计算序列长度、找出最大元素和最小元素
4.1.1 索引
通用序列操作
序列中的所有元素都可以通过索引〔下标〕来获取 从左往右，第一个元素的索引为0，第二个为1…… 索引还可以取负值，从右往左，最后一个元素的索引为-1，倒数第二个为-2……
本章首先介绍通用序列的操作，然后介绍字符串格式化操作和常用的字符串方 法，最后通过两个典型案例的分析和实现，让读者进一步掌握字符串的使用方法。
学习目标
掌握通用序列的操作方法 掌握字符串格式化操作方法 掌握常用的字符串方法 掌握针对字符串的程序设计方法
4.1.1 索引 4.1.2 分片 4.1.3 序列相加 4.1.4 乘法 4.1.5 长度、最小值和最大值
本章导读
本章引入了一个新的概念：数据结构。数据结构是通过某种方式〔如对元素进 行编号〕组织在一起的数据元素的集合，这些数据元素可以是数字或者字符，甚至 可以是其他数据结构。在Python中，最根本的数据结构是序列〔sequence〕，常 用的序列结构有字符串、列表和元组。本章将介绍字符串的使用，列表和元组将在 第5章介绍。
4.3 字符串方法
例：创立字符串new_str=“This is a Python book!〞，使用count() 方法找出其中“is〞 出现的次数。
字符串方法
new_str="This is a Python book!" a=new_str.count('is') b=new_str.count('is',1,6) print(a) print(b)
数据结构(CC++语言版)第4章串
•
else return -1;
•}
34
4.3 模式匹配
35
4.3 模式匹配
朴素的模式匹配——BF算法分析
为什么BF算法时间性能低？
在每趟匹配不成功时存在大量回溯，没有利用已经 部分匹配的结果。
如何在匹配不成功时主串不回溯？
主串不回溯，模式就需要向右滑动一段距离。
如何确定模式的滑动距离？
36
4.3 模式匹配
T[strLength(S1) +i]=S2[i]; strLength(T) =MAXSTRLEN; return FALSE; } }
CompStr (S, T)
初始条件：串 S 和 T 存在。 操作结果：若S T，则返回值 0；
若S T，则返回值 0； 若S T，则返回值 0
例如：CompStr(data, state) < 0 CompStr(capture, case) > 0
• 由于在计算机科学、生物信息学等许多领域的重要应用， 串模式匹配已经变成了一个非常重要的计算问题
28
4.3 模式匹配
常用的模式匹配算法： • 朴素的模式匹配（BF算法） • 无回溯的模式匹配（KMP算法） 其他模式匹配算法
29
4.3 模式匹配
朴素的模式匹配——BF算法
基本思想：从主串S的第一个字符开始和模式T 的第 一个字符进行比较，若相等，则继续比较两者的后 续字符；否则，从主串S的第二个字符开始和模式T 的第一个字符进行比较，重复上述过程，直到T 中的 字符全部比较完毕，则说明本趟匹配成功；或S中字 符全部比较完，则说明匹配失败。
S1="ab12 cd " S2="ab12" S3=“cd"
数据结构与算法 北京大学 4 第四章字符串 (4.2.1) 字符串的存储结构课件
数据结构与算法（四）张铭 主讲 采用教材：张铭，王腾蛟，赵海燕 编写 高等教育出版社，2008. 6 （“十一五”国家级规划教材）张铭《数据结构与算法》字符串主要内容目录页主要内容•字符串基本概念•字符串的存储结构–字符串的顺序存储–字符串类 class String 的存储结构•字符串运算的算法实现–字符串运算的实现–String 类的实现•字符串的模式匹配–朴素算法–KMP 快速模式匹配字符串的顺序存储•对串长变化不大的字符串，有三种处理方案1.用 S[0] 作为记录串长的存储单元 (Pascal)–缺点：限制了串的最大长度不能超过2562.为存储串的长度，另辟一个存储的地方–缺点：串的最大长度一般是静态给定的，不是动态申请数组空间3.用一个特殊的末尾标记‘\0’ (C/C++)–例如：C/C++ 语言的 string 函数库（＃include<string.h>）采用这一存储结构–‘\0’的 ASCII 字符表中编号为 0，等价于常量NULL、数字0、常量false字符串类的存储结构private: // 具体实现的字符串存储结构char *str; // 字符串的数据表示int size; // 串的当前长度例如，String s1 = "Hello";private:char *str;int size; // 值为5……字符串运算的算法实现•串长函数–int strlen(char *s);•串复制–char *strcpy(char *s1, char*s2); •串拼接–char *strcat(char *s1, char *s2); •串比较–int strcmp(char *s1, char *s2);串运算的实现// 求字符串的长度int strlen(char d[]){int i = 0;while(d[i]!=‘\0’)i++;return i;}串运算的实现// 字符串的复制char*strcpy(char*d,char*s){ int i = 0;while(s[i]!='\0'){d[i]= s[i]; i++;}d[i]='\0';return d;}串运算的实现// 字符串的比较int strcmp(const char *s1, const char *s2) { int i = 0;while (s2[i] != '\0' && s1[i] != '\0' ) {if (s1[i] > s2[i])return 1;else if (s1[i] < s2[i])return -1;i++;}if (s1[i] == '\0' && s2[i] != '\0')return -1;else if s2[i] == '\0' && s1[i] != '\0')return 1;return 0;}更简便的算法int strcmp_1(char *s1, char *s2) {int i;for (i = 0; s1[i] == s2[i]; ++i ) {if(s1[i] == '\0' && s2[i] == ‘\0')return 0; // 两个字符串相等 }// 不等, 比较第一个不同的字符return (s1[i]-s2[i]) / abs(s1[i]-s2[i]); }串运算的实现// 构造函数(constructor)String::String(char*s){// 先要确定新创字符串实际需要的存储空间，s的类型为(char *)，// 作为新创字符串的初值。
串的定义及基本运算
趟比较开始位置的下一个字符（i=i-j+2） ，同时将
子串的位置返回到第一个位置。
进行下次比较，直到匹配成功或者主串已经结束。
2020年1月30日
17
• 算法举例
主 串 S abbaba 子 串 T aba
第1趟 S a b b a b a T aba
3. 设定长串存储空间：char s[MAXSIZE+1]; 用s[0] 存放串的实际长度，串值存放在s[1]~s[MAXSIZE]，字 符的序号和存储位置一致，应用更为方便。
2020年1月30日
10
4.2.2 定长顺序串的基本运算
第四章 串
1.串联接：把两个串s1和s2首尾连接成一个新串s 。 int StrConcat1(s1,s2,s) { int i=0 , j, len1, len2;
(ii)在最坏的情况下，如果不成功的匹配都发生在子 串（t）的最后一个字符的位置，即每趟比较都要进行 m 次，这样比较的趟数要 n 趟，因此，此情况下的时 间复杂度为 O(n*m)。
例如：s=＂aaaaaaaaaab＂
t=＂aaaab＂
2020年1月30日
20
第四章 串
算法分析 优点：算法简单 实现容易 缺点：算法复杂度高； 重复比较次数比较，只要不匹配的情况，要 从新开始；回溯次数比较多。
8.串删除 StrDelete(s,i,len) 操作条件：串s存在，1≤i≤StrLength(s)， 0≤len≤StrLength(s)-i+1。 操作结果：删除串s 中从第i个字符开始的长度为 len的子串，s的串值改变。
9.串替换 StrRep(s,t,r) 操作条件：串s,t,r存在，t不为空。 操作结果：用串r 替换串s中出现的所有与串t相等
第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 串的有关概念串的基本操作2 串的定长顺序存储结构，堆分配存储结构；3 串的基本操作算法；4 串的模式匹配算法;5 串操作的应⽤。
学习要点1 了解串的基本操作，了解利⽤这些基本操作实现串的其它操作的⽅法；2 掌握在串的堆分配存储结构下，串的基本操作算法；3 掌握串的模式匹配算法；第四章串 4.1 串的基本概念4.2 串存储和实现4.3 串的匹配算法4.4 串操作应⽤举例第四章串 4.1 串的基本概念 4.2 串存储和实现 4.3 串的匹配算法 4.4 串操作应⽤举例第四章串4.1 串的基本概念 4.2 串存储和实现 4.3 串的匹配算法 4.4 串操作应⽤举例4. 1 串类型的定义⼀、串的定义1 什么是串串是⼀种特殊的线性表，它是由零个或多个字符组成的有,a2, a3, ... a n’限序列，⼀般记作s = ‘a1其中 s----串名， a1,a2, a3, ... a n----串值串的应⽤⾮常⼴泛，许多⾼级语⾔中都把串作为基本数据类型。
在事务处理程序中，顾客的姓名、地址；货物的名称、产地。
可作为字符串处理，⽂本⽂件中的每⼀⾏字符等也可作为字符串处理。
下⾯是⼀些串的例⼦：（1）a = ‘ LIMING’（2）b = ‘NANJING UNIVERSITY OF SCIENCE &TECHNOLOGY’（3）c = ‘ DATA STRUCTURE’（4）d = ‘’说明：1) 串中包含的字符个数，称为串的长度。
长度为0的串称为空串，它不包括任何字符，上⾯（4）中的串d 是空串,(5)中的e 是包含⼀个空格符的空格串；2）串中所包含的字符可以是字母、数字或其他字符，这依赖于具体计算机所允许的字符集。
2 串的有关术语1）⼦串串中任意连续的字符组成的⼦序列称为该串的⼦串例：c = ‘ DATA STRUCTURE’，f=‘DATA’ f是c的⼦串2）⼦串的位置⼦串T 在主串S中的位置是指主串S中第⼀个与T相同的⼦串的⾸字母在主串中的位置。
数据结构课后习题答案第四章
第四章串一、单项选择题1．B2. B3．B4．C5. C二、填空题1．空、字符2．由空格字符（ASCII值32）所组成的字符串空格个数3．长度、相等、子、主4．55．011223126．（1）char s[ ] (2) j++ (3) i >= j7．[题目分析]本题算法采用顺序存储结构求串s和串t的最大公共子串。
串s用i指针（1<=i<=s.len）。
t串用j指针（1<=j<=t.len）。
算法思想是对每个i（1<=i<=s.len，即程序中第一个WHILE循环），来求从i开始的连续字符串与从j（1<=j<=t.len，即程序中第二个ＷHILE循环）开始的连续字符串的最大匹配。
程序中第三个（即最内层）的WHILE循环，是当s中某字符（s［i］）与t中某字符（t［j］）相等时，求出局部公共子串。
若该子串长度大于已求出的最长公共子串（初始为０），则最长公共子串的长度要修改。
(1) i+k<=s.len && j+k<=t.len && s[i+k]==t[j+k] //所有注释同上（a）(2) con=0 (3) j+=k (4) j++ (5) i++三、应用题1．空格是一个字符，其ASCII码值是32。
空格串是由空格组成的串，其长度等于空格的个数。
空串是不含任何字符的串，即空串的长度是零。
2．(a)A+B “ mule”(b)B+A “mule ”(c)D+C+B “myoldmule”(d)SUBSTR(B,3,2) “le”(e)SUBSTR(C,1,0) “”(f)LENGTH(A) 2(g)LENGTH(D) 2(h)INDEX(B,D) 0(i)INDEX(C,”d”) 3(j)INSERT(D,2,C) “myold”(k)INSERT(B,1,A) “m ule”(l)DELETE(B,2,2) “me”(m)DELETE(B,2,0) “mule”3．朴素的模式匹配（Brute－Force）时间复杂度是Ｏ（m＊n），KMP算法有一定改进，时间复杂度达到Ｏ（m＋n）。
第4章 字符串 习题参考答案
第4章串习题参考答案一、基础知识题4.1 简述下列每对术语的区别：空串和空格串；串常量与串变量；主串和子串；串变量的名字和串变量的值；静态分配的顺序串与动态分配的顺序串。
【解答】不含任何字符的串称为空串，其长度为0。
仅含有空格字符的串称为空格串，其长度为串中空格字符的个数。
空格符可用来分割一般的字符，便于人们识别和阅读，但计算串长时应包括这些空格符。
空串在串处理中可作为任意串的子串。
用引号（数据结构教学中通常用单引号，而C语言中用双引号）括起来的字符序列称为串常量，串值可以变化的量称为串变量。
串中任意个连续的字符组成的子序列被称为该串的子串。
包含子串的串又被称为该子串的主串。
子串在主串中第一次出现的第一个字符的位置称子串在主串中的位置。
串变量的与其它变量一样，要用名字引用其值，串变量的名字也是标识符，串变量的值可以修改。
串的存储也有静态存储和动态存储两种。
静态存储指用一维数组，通常一个字符占用一个字节，需要静态定义串的长度，具有顺序存储结构的优缺点。
若需要在程序执行过程中，动态地改变串的长度，则可以利用标准函数malloc()和free()动态地分配或释放存储单元，提高存储资源的利用率。
在C语言中，动态分配和回收的存储单元都来自于一个被称之为“堆”的自由存储区，故该方法可称为堆分配存储。
类型定义如下所示：typedef struct{ char *str;int length;}HString;4.2设有串S=’good’，T=’I︼am︼a︼student’，R=’！’，求：（1）StringConcat(T，R) （2）SubString(T，8，7）（3）StringLength(T) （4）Index(T，’a’)（5）StringInsert(T，8，S)（6）Replace(T，SubString(T，8，7)，’teacher’)【解答】(1) StringConcat(T，R)=’I︼am︼a︼student！’(2) SubString(T，8，7）=’student’(3) StringLength(T)=14(4) Index(T，’a’)=3(5) StringInsert(T，8，S)=’I︼am︼a︼goodstudent’(6) Replace(T，SubString(T，8，7)，’teacher’)= ’I︼am︼a︼teacher’4.3若串S1=‘ABCDEFG’，S2=‘9898’，S3=‘###’，S4=‘012345’，执行concat(replace(S1，substr(S1，length(S2)，length(S3))，S3)，substr(S4，index(S2，‘8’)，length(S2))) 操作的结果是什么？【解答】concat(replace(S1,substr(S1,length(S2),length(S3)),S3),substr(S4，index(S2,‘8’),length(S2))) = concat(replace(S1,substr(S1,4,3),S3),substr(S4,2,4))= concat(replace(S1,’DEF’,S3),’1234’)= concat(‘ABC###G ’,’1234’)= ‘ABC###G1234’4.4 设S 为一个长度为n 的字符串，其中的字符各不相同，则S 中的互异的非平凡子串（非空且不同于S 本身）的个数是多少？【解答】长度为n 的字符串中互异的非平凡子串（非空且不同于S 本身）的个数计算如下： 长度为1的子串有n 个，长度为2的子串有n-1个，长度为3的子串有n-2个，……，长度为n-1的子串有2个，长度为n 的子串有1个（按题意要求这个子串就是S 本身，不能计算在总数内）。
ch4
串的块链存储类型： 串的块链存储类型： #define CHUNKSIZE 8 // 可由用户定义块大小 typedef struct Chunk { // 结点结构 char ch[CUNKSIZE]; struct Chunk *next; } Chunk; typedef struct ∥串的链表结构 {Chunk *head, *tail; ∥串的头和尾指针 int curlen; ∥串的当前长度 } LString;
（1）带长度的名字表 ） typedef struct {char name[maxsize]; int length; char *stadr; }lnode;
（2）带末指针的名字表 ） typedef struct {char name[maxsize]; char *stadr，*enadr; ， }enode; （3）带特征位的名字表 ） typedef struct {char name[maxsize]; int tag; union{char *stadr;} char value[4]; } uval; } tagnode;
串比较StrCmp (S, T) 串比较 初始条件： 初始条件：串 S 和 T 存在。 操作结果： 操作结果：若S > T，则返回值 > 0； ， ；
若S = T，则返回值 = 0； ， ； 若S < T，则返回值 < 0。 ， 。
例如： 例如：StrCmp(“data”, “state”) < 0 StrCmp(“cat”, “case”) > 0
c b a b
回遡的位置怎么判断？ i=i-j+1；j=0；匹配成功时 j大于等于字串的长度
c语言函数库-第四章(字符串函数)
c语言函数库第四章（字符串函数）1. atof：字符串转浮点型函数 (1)2. atoi：字符串转整型函数 (2)3. atol：字符串转长整型函数 (3)4. memchr：字符搜索函数 (4)5. memcmp：字符串比较函数 (4)6. memcpy：字符串拷贝函数 (5)7. memmove：字块移动函数 (6)8.memset：字符加载函数 (8)9. strcat：字符串连接函数 (8)10. strchr：字符串中字符首次匹配函数 (9)11. strcmp：字符串比较函数 (10)12. strcpy：字符串拷贝函数 (11)13. strcspn：字符集逆匹配函数 (12)14. strdup：字符串新建拷贝函数 (13)15. strerror：字符串错误信息函数 (14)16. strlen：计算字符串长度函数 (15)17. strlwr：字符串小写转换函数 (16)18. strncat：字符串连接函数 (16)19. strncmp：字符串子串比较函数 (17)20. strncpy：字符串子串拷贝函数 (18)21. strpbrk：字符集字符匹配函数 (19)22. strrchr：字符串中字符末次匹配函数 (20)23. strrev：字符串倒转函数 (21)24. strset：字符串设定函数 (22)25. strspn：字符集匹配函数 (22)26. strstr：字符串匹配函数 (23)27. strtod：字符串转换成双精度函数 (24)28. strtok：字符串分隔函数 (25)29. strtol：字符串转换成长整型函数 (27)30. strtoul：字符串转换成无符号长整型函数 (28)31. strupr：字符串大写转换函数 (29)32. strupr：字符串大写转换函数 (29)1.atof：字符串转浮点型函数函数原型：float atof(const char *str);头文件：#include<stdlib.h>是否是标准函数：是函数功能：将字符串转换成浮点值，也就是将字符串str转换成浮点值然后获取转换后的结果。
数据结构 第四章 串
第四章串串又称字符串，是一种特殊的线性表，它的每个元素仅由一个字符组成。
计算机上非数值处理的对象基本上是字符串数据。
在较早的程序设计语言中，字符串仅作为输入和输出的常量出现。
随着计算机应用的发展，在越来越多的程序设计语言中，字符串也可作为一种变量类型出现，并产生了一系列字符串的操作。
在信息检索系统、文字编辑程序、自然语言翻译系统等等应用中，都是以字符串数据作为处理对象的。
本章将讨论串的存储结构和基本操作。
4.1 串的基本概念4.1.1 串的自然语言定义串(string)(或字符串)是由零个或多个字符组成的有限序列，一般记为：S="a1 a2 …… a n" (n≥0)其中，S是串名，用双引号括起来的字符串序列是串的值；a i(1≤i≤n)可以是字母、数字或其他字符；串中字符的个数n称为串的长度。
长度为0的串称为空串。
需要注意的是，串值必须用一对双引号括起来，但双引号本身不属于串，它的作用只是为了避免与变量名或数的常量混淆。
如"tempt"是个串,tempt则是变量名；"23"是串,而23则是一个常量.串中任意个连续的字符组成的子序列称为该串的子串，如：串S＝"This is a string"，其中"This"是一个子串，"string"也是一个子串。
求子串在串中的起始位置称为子串定位或模式匹配。
例如，设A，B，C为如下三个串：A＝"data"，B="structure"，C＝"data structure"，则它们的长度分别是4,9，14，A和B都是C的子串，A在C中的位置是1，而B在C中的位置是6。
下面注意区别空格串与空串的概念。
在各种应用中，空格常常是串的字符集合中的一个元素，因而可以出现在其他字符中间。
由一个或多个空格组成的串称为空格串，也就是说空格串中只有空格字符，空格串的长度不为零。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
4.3.2
无回溯的模式匹配
由D.E.Knuth与V.R.Pratt和J.H.Morris同 时发现的。简称KMP算法。 设 主 串 S=“ababcabcacbab”, 模 式 串 T=“abcac”。 则普通算法的匹配过程如下：
朴素匹配情况： 朴素匹配情况：
第一趟匹配 第二趟匹配
ababcabcacbab abcac ababcabcacbab abcac ababcabcacbab abcac ababcabcacbab abcac ababcabcacbab abcac ababcabcacbab abcac
串的基本运算
创建一个空串 string createNullStr(void) 判断一个串是否为空串 int isNullstr(String s) 求一个串的长度 int length(String s) 将两个串拼接在一起构成一个新串 String concat(String s1, String s2) 在串s中，求从串的第i个字符开始连续j个字符所构成的子串 String subStr(String s, int i, int j) 求串S2在串S1中第一次出现的位置 位置 int index(String s1,String s2)
小 结
串是特殊的线性表，是由字符作元素组成的。它和 线性表一样有顺序存储和链式存储两种方式。串作为 一种抽象数据类型，有它自己的操作，在对串处理时 ，要抓住它的特殊要求。 模式匹配是一个比较复杂的串操作，是子串在主串 中的定位操作。朴素的模式匹配算法比较直观，易于 理解；但无回溯的模式匹配算法的技巧性很强，读懂 它需要费一定的时间，不过一旦真正弄懂了这个算法 ，将会极大地增强你的学习兴趣。
算法4.7
计算next数组
makeNext(PSeqString p, int *next) { int i, k; k= -1; i=0; next[0]= -1; /* 初始化 */ /* 计算next[i+1] */
while (i<p->n-1) {
while (k>=0 && p->c[i]!=p->c[k]) k = next[k]; i++; next[i] = k; /*改进：if(p->c[i]= =p->c[k]) next[i]= next[k]; else next[i] = k; */ k++;
表4.1 计算next数组 p=“abcaababc”
下标 i pi k
Pk 与 pi 比较
0 a
1 b 0
2 c 0 ≠ 0
3 a 0 =
4 a 1
5 b 1 = 0
6 a 2 ≠ 2
7 8 b c 1 2 = = 0 0
Next[i]
≠ -1 0
≠ -1 1
KMP算法的优点：不需回溯。这对于从外设读 入的庞大文件很有效，可以边读入边匹配，无须回头 重读。无回溯匹配时间复杂性：O(n).
4.2.2
链接表示
链接串的定义
struct StrNode ; typedef struct StrNode *p StrNode; struct StrNode { char c; pStrNode link; }; typedef struct StrNode *LinkString;
s a b (a) 不带头结点 s
pi匹配失败时，对应k值只与p有关，与被匹配串无关 用next[i] 表示与i 对应的k 值，其含义是： 当pi≠tj时，若next[i] ≥ 0 则用pk(p next[i] )与tj 比较。 否则（next[i]= -1 时）用p0与tj+1比较。 对任何模式p，需要确定next[i] (i=0,1,…,m-1)的值。 当pi≠tj时，直接右移i - next[i]个字符， 直接用p next[i] （当next [i] 大于等于0）与tj比较； 或用p0 （当next [i] 等于-1）与tj+1比较。 显然对于任何模式都有：next [0] = -1
第四章
4.1 4.2 4.3
字符串
字符串及其运算 字符串的存储表示 模式匹配
4.1 字符串及其运算
字符串：简称串，是特殊的线性表，其特殊性主 要在于表中的每个元素是一个字符，以及由此而 要求的一些特殊操作。 长度：一个串中包括的字符个数。长度为零的串 称为空串。 子串：字符串s1中任意个连续的字符组成的子序 列s2被称为是s1的子串，而称s1是s2的主串。 位置：子串在主串中的位置是以子串的第一个 第一个字 第一个 符在主串中的字符序号(下标+1)。 相等：两个串的长度相等，并且对应位置上的字 符都 相等。
朴素的模式匹配 无回溯的模式匹配
4.3.1
朴素的模式匹配
t p
a a 图4.3
b a b
b a b
a a b
b a b
a a
朴素的模式匹配过程
朴素匹配算法简单，易于理解，但效率不高，主要 原因是执行中有回溯，一旦比较不等，就将p所指的串 右移一个字符，并从p0（算法中用p->c[0]表示）开始比 较。在最坏的情况下，每趟比较都在最后出现不等，最 多比较n－m＋1趟，总比较次数为m*(n－m＋1)，由于 在一般情况下m＜＜n，所以算法运行时间为O(m*n)。 主串： “000000000000000000000000000000000000000000001” 模式串： “00000001”
} }
t0…tj-i-1p0…pj-1 tj…
‖ ‖ ≠
p0…pi-1pi… t0…tj-i-1 p0…pi-k&…
改进：当 pi ≠ tj 时,如果pi=pk，结果仍然 pk ≠ tj 。
所以应再右移k-next[k]位。使p next[k]与tj比较。
4.2
串的存储表示
4.2.1 4.2.2
顺序表示 链接表示
4.2.1
顺序表示
顺序串的定义
#define MAXNUM /* 串允许的最大字符个数 */ struct SeqString /* 顺序串的类型 */ { char c[MAXNUM]; int n; /* 串的长度，n≤MAXNUM */ }; typedef struct SeqString *PSeqString;
….
f
∧
a (b) 带头结点
b
….
f
∧
s
a b
….
f
(c) 循环表表示
图4. 2 串的链接表示例
4.3 模式匹配
模式匹配：子串在主串中的定位操作(m<<n)。 ： t=t0 t1 t2 … tn-1 p=p0 p1 p2 … pm-1 目标 模式
从目标t中查找与模式p完全相同子串的过程。
4.3.1 4.3.2
利用next[0]=-1，……next [i],求next [i +1] 的算法： 设next [i]=k， 若pk=pi则p0… pi-k…pi中最大相同前后缀的长度为k=k+1; 否则 置k为next[k] 重复上面（若pk=pi）的判断。 最多碰到某个next为-1时，得到p0… pi-k…pi中最大相同 前后缀的长度为k=0（即next [i +1] =0）。
第三趟匹配 第四趟匹配 第五趟匹配 第六趟匹配
KMP算法匹配情况： KMP算法匹配情况： 算法匹配情况
第一趟匹配 第二趟匹配
ababcabcacbab abcac ababcabcacbab abcac ababcabcacbab (a)b c a c
第三趟匹配
要解决的问题： 匹配中遇到pi≠tj ，下一步用p中哪个字符和tj比较？ 要找到相应的pk，0≤k<i
设A＝“123” B＝“ABBABBC” C = “BB” D = “” 1、A、B、C、D四个串的长度分别为3，7，2，0 2、将A,B拼接在一起的新串为“123ABBABBC” 3、从串B中第四个字符开始连续取三个字符所构成的 子串为“ABB” 4、串C是串B的子串，且在串B中第一次出现的位置 为2
对于next[i]=k 的改进： 的改进： 对于
因为若pk=pi,则pk≠tj. 所以应再右移，使pnext[k]与tj比较， 改进为 if (pk= =pi) next[i]=next[k]; else next[i]=k;
算法4.7 计算next数组（改进后） makeNext(PSeqString p, int *next)
分析： 值仅依赖于 本身前i个字符 值仅依赖于p本身前 分析：k值仅依赖于 本身前 个字符 t0…tj-i-1tj-i…tj-1 tj…
‖ ‖ ≠
p0…pi-1pi… t0…tj-i-1 p0…pi-1tj…
‖ 图 4.4 ‖ ≠
p0…pi-1pi…
发现pi≠tj的状态
后缀
t0…tj-i-1 p0… pi-k…pi-1 tj… p0 …pk-1 pk…
/* 变量next是数组next的第一个元素next[0]的地址 */
{
int i, k; k= -1; i=0; next[0]= -1; /* 初始化 */ while (i<p->n-1) /* 计算next[i+1] */ { while (k>=0 && p->c[i]!=p->c[k]) k = next[k]; i++; k++; if(p->c[i]= =p->c[k]) next[i]= next[k]; else next[i] = k; } }
前缀 图 4.5 p0…pi-1的前缀与其后缀比较 设p0…pi-1中最大相同的前缀与其后缀（不包括 p0…pi-1本身，但允许空串）的长度为k(0≤k<i-1)。当 pi≠tj时，右移i-k位，使pk与 tj比较（即next[i]=k）。