计算机基础知识：串的模式匹配之求子串位置的定位函数
串的模式匹配算法
串串（String）又叫做字符串，是一种特殊的线性表的结构，表中每一个元素仅由一个字符组成。
随着计算机的发展，串在文字编辑、词法扫描、符号处理以及定理证明等诸多领域已经得到了越来越广泛的应用。
第一节串的定义和表示1、串的逻辑结构定义串是由零个到任意多个字符组成的一个字符序列。
一般记为：S=’ a1a2a3……a n’(n>=0)其中S为串名，序列a1a2a3……a n为串值，n称为串的长度，我们将n=0的串称为空串(null string)。
串中任意一段连续的字符组成的子序列我们称之为该串的子串，字符在序列中的序号称为该字符在串中的位置。
在描述中，为了区分空串和空格串(s=‘’)，我们一般采用来表示空串。
2、串的基本操作串一般包含以下几种基本的常用操作：1、length(S)，求S串的长度。
2、delete(S,I,L)，将S串从第I位开始删除L位。
3、insert(S,I,T)，在S的第I位之前插入串T。
4、str(N,S)，将数字N转化为串S。
5、val(S,N,K)，将串S转化为数字N；K的作用是当S中含有不为数字的字符时，K记录下其位置，并且S没有被转化为N。
3、串的储存结构一般我们采用以下两种方式保存一个串：1、字符串类型，描述为：const n=串的最大长度type strtype=string[n]这里由于tp的限制，n只能为[1..255]。
在fp或者delphi中，我们还可以使用另外一种类型，描述为：const n=串的最大长度type strtype=qstring[n]这里的n就没有限制了，只要空间允许，开多大都可以。
2、数组来保存，描述为：const n=串的最大长度type strtype=records:array[1..n] of char;len:0..n;end;第二节模式匹配问题与一般的线性表不同，我们一般将串看成一个整体，它有一种特殊的操作——模式匹配。
串与序列算法
串与序列算法串和序列是计算机中非常重要的概念，它们在数据处理和算法设计中都有广泛应用。
本文将介绍串与序列算法的基本知识和相关操作。
一、串算法1. 串的定义：串是由零个或多个字符组成的有限序列，一般用字符串表示。
例如，"Hello World"就是一个由字符串构成的串。
2. 串的基本操作：串的基本操作包括串的赋值、串的拼接、串的截取、串的查找和串的比较操作等。
其中，串的赋值操作是将一个字符串赋值给一个串变量。
例如：string a = "Hello World";串的拼接操作是将两个串连接成一个新的串。
例如：string a = "Hello";string b = "World";string c = a + b; //输出Hello World串的截取操作是从一个串中截取出一段子串。
例如：string a = "Hello World";string b = a.substr(0, 5); //输出"Hello"串的查找操作是在一个串中查找另一个子串的位置。
例如：string a = "Hello World";int pos = a.find("World"); //输出6串的比较操作是比较两个串的大小关系。
例如：string a = "Hello";string b = "World";if(a < b){cout<<"a is smaller than b"<<endl;}else{cout<<"a is bigger than b"<<endl;}3. 串匹配算法：串匹配算法是指在一个串中查找另一个子串的位置，它的应用非常广泛。
第4章串(String)(2)专题知识讲座
BF算法旳基本思想图解 本趟匹配开始位置
主串S 模式T
回溯 i
si
…
tj
j 回溯
……
25
BF算法用伪代码 : 1. 在串S和串T中设比较旳起始下标i和j； 2. 循环直到S中所剩字符个数不大于T旳长度或T旳
全部字符均比较完 2.1 假如S[i]=T[j]，继续比较S和T旳下一种字符； 2.2 不然将i和j回溯(j=0, i为此次比较旳最初字符 旳下一种字符旳下标)，准备下一趟比较； 3. 假如T中全部字符均比较完，则匹配成功，返回 匹配旳起始比较下标；不然，匹配失败，返回0；
4
二、串旳抽象数据类型
数据集合：串旳数据集合能够表达为字符序列 s0,s1, ……,sn-1，每
个数据元素旳数据类型为字符类型。
操作集合：
(1)初始化串 Initiate(S)
(2)赋值
Assign( S, T)
(3)求串长度 strLength( S )
(4)比较
Compare( S, T)
(5)插入
13
2、顺序串旳紧缩存储方式
以字节为单位顺序存储字符串旳每个字符，根据机器字旳 长度，紧缩存储措施尽量地将多种字符存储在一种字中。 对于字符串s =“data structures”，非紧缩存储方式下字 符串s旳顺序存储构造如下：（假设字长为4）
14
2、串旳链式存储构造
它分为单字符结点和块链两种。
18
b.链串
(1)链串赋值
void strassign(linkstring *s, char t[])
{
int k=0; linkstring *r,*p;
s = (linkstring *)malloc(sizeof(linkstring)); s->data = ‘#’; r=s; while (t[k]!=‘\0’) { p=(linkstring *) malloc(sizeof(linkstring));
python字符串匹配算法
python字符串匹配算法一、引言在计算机科学中，字符串匹配是指在文本中查找特定模式的子串。
这种操作在很多实际应用中都非常重要，例如在文件搜索、数据过滤、自然语言处理等领域。
Python提供了一些内置函数和库，可以方便地进行字符串匹配。
二、基本算法1. 朴素字符串匹配算法（Naive String Matching）：这是一种简单的字符串匹配算法，通过遍历文本串，逐个字符地与模式串进行比较，以确定是否存在匹配。
2. 暴力匹配算法（Brute Force）：这是一种基于字符比较的字符串匹配算法，通过逐个字符地比较文本串和模式串，直到找到匹配或者遍历完整个文本串为止。
3. KMP算法（Knuth-Morris-Pratt Algorithm）：这是一种高效的字符串匹配算法，通过记忆已经比较过的字符，减少不必要的重复比较，从而提高匹配速度。
三、Python实现1. 朴素字符串匹配算法：在Python中，可以使用`str.find()`方法或`str.index()`方法来查找模式串在文本串中的位置。
示例如下：```pythontext = "Hello, world!"pattern = "world"index = text.find(pattern)if index != -1:print("Pattern found at index", index)else:print("Pattern not found")```2. 暴力匹配算法：在Python中，可以使用`re`模块来实现暴力匹配算法。
示例如下：```pythonimport retext = "Hello, world! This is a test."pattern = "world"matches = re.findall(pattern, text)if matches:print("Pattern found in text")else:print("Pattern not found in text")```3. KMP算法：在Python中，可以使用`re`模块中的`search()`方法来实现KMP算法。
串的模式匹配算法
串的模式匹配算法字符串模式匹配是计算机科学中一种常用的算法。
它是一种检索字符串中特定模式的技术，可以用来在字符串中查找相应的模式，进而完成相应的任务。
字符串模式匹配的基本思想是，用一个模式串pattern去匹配另一个主串text，如果在text中找到和pattern完全匹配的子串，则该子串就是pattern的匹配串。
字符串模式匹配的过程就是在text中搜索所有可能的子串，然后比较它们是否和pattern完全匹配。
字符串模式匹配的算法有很多，其中著名的有暴力匹配算法、KMP算法、BM算法和Sunday算法等。
暴力匹配算法是最简单也是最常用的字符串模式匹配算法，其思想是从主串的某一位置开始，依次比较pattern中每一个字符，如果某个字符不匹配，则从主串的下一位置重新开始匹配。
KMP算法（Knuth-Morris-Pratt算法）是一种更为高效的字符串模式匹配算法，它的特点是利用了已匹配过的字符的信息，使搜索更加有效。
它的实现思想是，在pattern中先建立一个next数组，next数组的值代表pattern中每个字符前面的字符串的最大公共前缀和最大公共后缀的长度，这样可以在主串和模式串匹配失败时，利用next数组跳转到更有可能匹配成功的位置继续搜索，从而提高字符串模式匹配的效率。
BM算法（Boyer-Moore算法）也是一种高效的字符串模式匹配算法，它的实现思想是利用主串中每个字符最后出现的位置信息，以及模式串中每个字符最右出现的位置信息来跳转搜索，从而减少不必要的比较次数，提高搜索效率。
Sunday算法是一种简单而高效的字符串模式匹配算法，它的实现思想是，在主串中搜索时，每次从pattern的最右边开始比较，如果不匹配，则根据主串中下一个字符在pattern中出现的位置，将pattern整体向右移动相应位数，继续比较，这样可以减少不必要的比较次数，提高算法的效率。
字符串模式匹配算法的应用非常广泛，它可以用来查找文本中的关键字，检查一个字符串是否以另一个字符串开头或结尾，查找文本中的模式，查找拼写错误，检查字符串中是否包含特定的字符等。
求子串函数strstr()的函数
求子串函数strstr()的函数在C语言中，字符串是用字符数组来表示的，而函数strstr()则是用来查找一个字符串中是否具有另一个字符串的函数，其全称为“string search”，也就是字符串查找。
本文将从以下几个方面来介绍函数strstr()的相关知识。
一、函数原型函数strstr()的原型如下：```cchar *strstr(const char *str1, const char *str2);```其中，str1为被查找的字符串，str2为要查找的字符串，返回值为在str1中第一次出现str2的位置指针，如果找不到则返回NULL。
二、函数功能函数strstr()的功能是查找字符串中是否包含另一个字符串，如果包含则返回第一次出现位置的指针，不包含则返回NULL。
具体用法如下：```cchar str1[] = "hello world";char str2[] = "world";char *p;p = strstr(str1, str2);if(p)printf("在%s中，第一次出现%s的位置为%d\n", str1, str2,p-str1+1);elseprintf("在%s中，没有找到%s\n", str1, str2);```输出结果为：```c在hello world中，第一次出现world的位置为7```三、函数实现原理函数strstr()的实现原理是在字符串str1中循环查找字符串str2，直到找到第一次出现的位置或遍历完整个字符串。
具体实现方式为，先找到字符串str2的第一个字符，然后从该字符开始依次比较str1和str2中的字符，如果相等则一直比较下去，一旦不相等则退出比较，继续在字符串str1中查找下一个与str2中第一个字符相同的字符，再进行上述比较操作，直到找到第一次出现的位置或遍历完整个字符串。
excel中查找字符串所在单元格位置的函数
excel中查找字符串所在单元格位置的函数在Excel中，要查找字符串所在的单元格位置，有多种方法和函数可以实现。
下面将介绍几种常用的方法。
1. 查找函数- FIND:FIND函数用于在文本字符串中查找指定的子字符串，并返回子字符串开始位置的位置编号。
下面是示例公式：=FIND("要查找的字符串",A1)该公式将在A1单元格中查找指定的字符串，并返回字符串首次出现的位置。
2. 查找函数- SEARCH:SEARCH函数与FIND函数类似，但不区分大小写。
下面是示例公式：=SEARCH("要查找的字符串",A1)3. 匹配函数- MATCH:MATCH函数返回指定值在指定范围或数组中的相对位置。
下面是示例公式：=MATCH("要查找的字符串",A1:A10,0)该公式将在A1到A10的范围中查找指定的字符串，并返回字符串首次出现的行号。
4. 过滤函数- FILTER:FILTER函数用于筛选满足指定条件的数据，可以用于查找包含指定字符串的单元格。
下面是示例公式：=FILTER(A1:A10,ISNUMBER(SEARCH("要查找的字符串",A1:A10)))该公式将在A1到A10的范围中筛选出包含指定字符串的单元格。
5. VBA宏- INSTR函数:通过编写VBA宏，可以使用INSTR函数来查找字符串所在的单元格位置。
下面是示例代码：Sub FindString()Dim rng As RangeDim cell As RangeDim searchString As StringsearchString = "要查找的字符串"Set rng = Range("A1:A10")For Each cell In rngIf InStr(cell.Value, searchString) > 0 ThenMsgBox "找到字符串'" & searchString & "' 在单元格" & cell.AddressEnd IfNext cellEnd Sub在VBA编辑器中，将此代码复制粘贴到模块中，并执行宏，即可查找包含指定字符串的单元格。
串的数据结构实验报告
串的数据结构实验报告串的数据结构实验报告一、引言在计算机科学中，串（String）是一种基本的数据结构，用于存储和操作字符序列。
串的数据结构在实际应用中具有广泛的用途，例如文本处理、搜索引擎、数据库等。
本实验旨在通过实践掌握串的基本操作和应用。
二、实验目的1. 理解串的概念和基本操作；2. 掌握串的存储结构和实现方式；3. 熟悉串的常见应用场景。
三、实验内容1. 串的定义和基本操作在本实验中，我们采用顺序存储结构来表示串。
顺序存储结构通过一个字符数组来存储串的字符序列，并使用一个整型变量来记录串的长度。
基本操作包括：- 初始化串- 求串的长度- 求子串- 串的连接- 串的比较2. 串的模式匹配串的模式匹配是串的一个重要应用场景。
在实验中，我们将实现朴素的模式匹配算法和KMP算法，并比较它们的性能差异。
四、实验步骤1. 串的定义和基本操作首先，我们定义一个结构体来表示串，并实现初始化串、求串的长度、求子串、串的连接和串的比较等基本操作。
2. 串的模式匹配a. 实现朴素的模式匹配算法朴素的模式匹配算法是一种简单但效率较低的算法。
它通过逐个比较主串和模式串的字符来确定是否匹配。
b. 实现KMP算法KMP算法是一种高效的模式匹配算法。
它通过利用已匹配字符的信息，避免不必要的比较，从而提高匹配效率。
3. 性能比较与分析对比朴素的模式匹配算法和KMP算法的性能差异，分析其时间复杂度和空间复杂度，并讨论适用场景。
五、实验结果与讨论1. 串的基本操作经过测试，我们成功实现了初始化串、求串的长度、求子串、串的连接和串的比较等基本操作，并验证了它们的正确性和效率。
2. 串的模式匹配我们对两种模式匹配算法进行了性能测试，并记录了它们的运行时间和内存占用情况。
结果表明，KMP算法相较于朴素算法，在大规模文本匹配任务中具有明显的优势。
六、实验总结通过本实验，我们深入学习了串的数据结构和基本操作，并掌握了串的模式匹配算法。
实现顺序串的各种模式匹配算法
实现顺序串的各种模式匹配算法序号一：引言实现顺序串的各种模式匹配算法是一项重要而复杂的任务。
在计算机科学领域，这一问题一直备受关注，因为它涉及到如何高效地在一个文本中找到一个模式的出现。
通过使用不同的算法和数据结构，我们可以在实际应用中更有效地实现字符串匹配。
在本文中，我们将深入探讨各种模式匹配算法，包括它们的原理、优缺点以及适用场景，以便读者能够更全面地理解和应用这些算法。
序号二：模式匹配算法的基本原理在开始讨论不同的模式匹配算法之前，让我们先了解一下模式匹配的基本原理。
模式匹配是指在一个文本串中查找一个模式串的过程。
具体来说，我们需要在文本串中以每一个位置为起点，依次比较模式串和文本串的对应字符，从而确定模式串是否出现在文本串中。
这个过程类似于在一本书中找到特定章节的名字，只不过在计算机中我们需要以更快的速度完成这一任务。
序号三：常见的模式匹配算法及其优缺点在实际应用中，有许多不同的模式匹配算法可供选择。
其中，最常见的包括朴素匹配算法、KMP算法、Boyer-Moore算法、Rabin-Karp 算法等。
每种算法都有其独特的优缺点，以适应不同的应用场景。
朴素匹配算法是一种简单直观的算法，它从文本串的每一个位置开始和模式串进行匹配，直到找到匹配或者遍历完整个文本串为止。
这种算法的优点是实现简单，但是对于大规模文本串和模式串来说效率较低。
KMP算法是一种高效的模式匹配算法，它利用了模式串自身的特点来快速匹配文本串。
通过构建部分匹配表，KMP算法可以在匹配过程中跳过一些已经匹配过的位置，从而提高匹配的效率。
其主要缺点是需要额外的空间来存储部分匹配表，因此在内存有限的场景下可能不适用。
Boyer-Moore算法是另一种经典的模式匹配算法，它通过利用模式串和文本串之间的信息来跳过一些不可能匹配的位置，从而减少比较次数。
这使得Boyer-Moore算法在最坏情况下的时间复杂度较低，适用于大规模文本串和模式串的匹配。
子串定位运算[大全]
![子串定位运算[大全]](https://img.taocdn.com/s3/m/29c68fe1bb0d4a7302768e9951e79b8968026811.png)
子串定位运算子串定位运算串是特殊的线性表，故顺序串和链串上实现的运算分别与顺序表和单链表上进行的操作类似。
C 语言的串库 <string.h> 里提供了丰富的串函数来实现各种基本运算，因此我们对各种串运算的实现不作讨论。
利用串函数实现串的基本运算部分内容【参见练习】。
下面讨论在顺序串和链串上实现的子串定位运算。
1 、子串定位运算子串定位运算类似于串的基本运算中的字符定位运算。
只不过是找子串而不是找字符在主串中首次出现的位置。
此运算的应用非常广泛。
【例】在文本编辑中，我们经常要查找某一特定单词在文本中出现的位置。
解此问题的有效算法能极大地提高文本编辑程序的响应性能。
子串定位运算又称串的模式匹配或串匹配。
2 、目标（串）和模式（串）在串匹配中，一般将主串称为目标（串），子串称为模式（串）。
假设 T 为目标串， P 为模式串，且不妨设：T="t 0 t 1 t 2 …t n-1 "P="p 0 p 1 p 2 …p m-1 "(0 ＜m≤n)3 、串匹配串匹配就是对于合法的位置（又称合法的位移）0≤i≤n-m ，依次将目标串中的子串"t i t i+1 …t i+m-1 " 和模式串"p 0 p 1 p 2 …p m-1 " 进行比较：① 若"t i t i+1 …t i+m-1 " ＝"p 0 p 1 p 2 …p m-1 " ，则称从位置 i 开始的匹配成功，或称 i 为有效位移。
② 若"t i t i+1 …t i+m-1 "≠"p 0 p 1 p 2 …p m-1 " ，则称从位置 i 开始的匹配失败，或称 i 为无效位移。
因此，串匹配问题可简化为找出某给定模式串 P 在给定目标串T 中首次出现的有效位移。
注意：有些应用中要求求出 P 在 T 中所有出现的有效位移。
KMP
KMP算法
next函数的改进 函数的改进
aaabaaaab aaaa ① ② ③
j=4 j=3 j=2 j=1 i=4
j
12345
模式 a a a a b next[j] 0 1 2 3 4 nextval[j] 0 0 0 0 4
aaa aa a
aaaab i = 5; j = 1
next[j] = k,而pj=pk, , 主串中s 不等时, 则 主串中 i和pj不等时, 不需再和p 进行比较, 不需再和 k进行比较, 而直接和p 而直接和 next[k]进行比 较.
第 1 次匹配 s= cddcdc t=cdc 第 2 次匹配 s= cddcdc t=cdc 第 3 次匹配 s= cddcdc t=cdc 第 4 次匹配 s= cddcdc t=cdc i= 3 j= 3 i= 2 j= 1 i= 3 j= 1 i= 6 j= 3 成功 失败 失败 失败
i = i –j +2; j = 1;
KMP算法
j 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 模式串 a b c a a b b c a b c a a b d a b next[j] 0 1 1 1 2 2 3 1 1 2 3 4 5 6 7 1 2
nextval[j]
0 1 1 0 2 1 3 1 0 1 1 0 2 1 7 0 1
KMP算法
KMP算法的时间复杂度 KMP算法的时间复杂度 设主串s 的长度为n, 模式串t 长度为m, KMP算 n,模式串 m,在 设主串 s 的长度为 n, 模式串 t 长度为 m, 在 KMP 算 法中求next 数组的时间复杂度为 O(m),在后面的匹 法中求 next数组的时间复杂度为 O(m), 在后面的匹 next 数组的时间复杂度为O(m), 配中因主串s的下标不减即不回溯,比较次数可记为 配中因主串s的下标不减即不回溯, n,所以KMP算法总的时间复杂度为O(n+m). n,所以KMP算法总的时间复杂度为O(n+m). 所以KMP算法总的时间复杂度为O(n+m)
包含数据匹配的函数
包含数据匹配的函数
数据匹配是指在一组数据中查找特定值或模式的过程。
在计算机编程中，通常使用函数来实现数据匹配。
常见的包含数据匹配功能的函数包括：
1. 搜索函数，例如在Python中的`find()`或`index()`函数，用于在字符串中查找特定子串的位置或索引。
2. 正则表达式函数，正则表达式是一种强大的模式匹配工具，常见的函数包括在Python中的`re.match()`、`re.search()`和
`re.findall()`等，用于在文本中匹配特定模式的字符串。
3. 数据库查询函数，在数据库操作中，可以使用SQL语句中的`SELECT`语句来实现数据匹配，例如`SELECT FROM table WHERE condition`用于从数据库表中匹配满足特定条件的数据。
4. 列表操作函数，在编程语言中，可以使用列表操作函数来进行数据匹配，例如在Python中的`filter()`函数可以根据指定的函数过滤列表中的元素。
5. 字典操作函数，在Python中，可以使用字典操作函数如
`get()`、`setdefault()`等来进行键-值对的匹配操作。
6. 模糊匹配函数，有时候需要进行模糊匹配，例如在搜索引擎中常用的模糊匹配算法包括编辑距离算法，可以通过Levenshtein 距离或者其他相似度算法来实现模糊匹配。
以上是一些常见的包含数据匹配功能的函数，它们可以根据具体的需求和编程语言来选择合适的函数来实现数据匹配操作。
希望这些信息能够帮助到你。
串的基本操作
一．实验目的如果计算机语言没有把串作为一个预先定义好的基本类型对待，又需要用该语言写一个涉及串操作的软件系统时，用户必须自己实现串类型。
试着实现串类型，并写一个串的基本操作演示系统。
二．实验内容实现若干串的常用基本操作，如串赋值、求串长、串替换、串比较、求子串及串的模式匹配等。
模块设计本程序包含两个模块：主程序模块、串操作模块。
其调用关系如图2所示。
图2 模块调用关系示意图三．实验步骤（可选）数据类型定义(1) 字符串的定义typedef struct{char *ch; //串存放的数组int curLen; //串的长度}HString;(2) 全局变量声明#define OK 1 //操作成功#define OVERFLOW 0 //溢出#define ERROR 0 //出错系统主要子程序详细设计(1)主程序模块设计主函数。
设定用户操作界面，调用操作模块函数。
void main(){输出操作菜单；Switch (1){输出操作序号c；switch (c){调用相应函数执行相应操作；输出操作结果；}}}(2)求子串int substring(HString &Sub,HString S,int pos,int len){ //´串sub返回串S的第pos个字符起长度为len的子串int i;if(pos<0||pos>S.curLen||len<0||len>S.curLen-pos){ //若位置或长度不合法，退出printf("输入不合法\n");exit(OVERFLOW); //退出}else{if(Sub.ch) free(Sub.ch); //释放子串sub原有空间if(!len) //若长度len为0{ //就爱那个子串置为空串Sub.ch=NULL;Sub.curLen=0;}else //若长度len不为0{Sub.ch=(char*)malloc(len*sizeof(char));for(i=0; i<len; i++){ //从串S的第pos个字符开始依次复制其后长度为len的字符串sub中Sub.ch[i]=S.ch[pos-1+i];Sub.curLen=len; //修改串sub的串长}}return OK;}}(3)子串定位（串的模式匹配）int Index(HString &ob1,HString &ob2,int pos){ //判断从第pos个字符起，ob2是否为ob1的子串//若是返回ob2在ob1中的起始位置，否则返回-1if(pos<0||pos>ob1.curLen){//若输入的数值pos不在ob1的串长范围内printf("输入有误\n");exit(ERROR);}for(int i=pos-1; i<=StrLength(ob1)-StrLength(ob2); i++){ //从ob1的第pos个字符起查找子串ob2int j=0; //从ob2的第一个字符起开始查找while(j<StrLength(ob2)) //j控制查找位置，逐个字符查找，直到超出子串串长{if(ob1.ch[i+j]==ob2.ch[j]) //若找到匹配字符j++; //则依次向后查找else break; //一旦失配，则跳出查找，此时j还未能达到子串串长}if(j==StrLength(ob2)) //若j达到子串串长，即ob2的所有字符都能和ob1匹配return i; //返回ob2在ob1的起始位置i}return -1; //ob2不是ob1的子串，返回-1}(4)串替换void Replace(HString &ob1,HString &ob2,HString &ob3){ //将原串ob1的所有子串ob2都替换为插入串ob3printf("原串：");for(int i=0; i<ob1.curLen; i++)printf("%c",ob1.ch[i]);printf("\n 子串：");for(int j=0; j<ob2.curLen; j++)printf("%c",ob2.ch[j]);printf("\n");printf("插入串：");for(int k=0; k<ob3.curLen; k++)printf("%c",ob3.ch[k]);printf("\n");int len=StrLength(ob2); //ob2的长度while(Index(ob1,ob2,0)!=-1) //当ob2是ob1的子串，替换所有的ob2 {int len2=StrLength(ob3)+StrLength(ob1)-StrLength(ob2); //新串的长度int i=Index(ob1,ob2,0); //调用子串定位函数char *p=new char[StrLength(ob1)-i-len+1]; //临时数组char *q=new char[len2]; //存储新串的数组for(int j=i+len; j<StrLength(ob1); j++)p[j]=ob1.ch[j]; //将不用替换的后部分存入数组pfor(int k=0; k<i; k++)q[k]=ob1.ch[k]; //将不用替换的前部分存入数组q for(int m=i; m<i+StrLength(ob3); m++)q[m]=ob3.ch[m-i]; //替换子串int b=i+len;for(int n=i+StrLength(ob3); n<len2; n++){ //将不用替换的后部分存入数组qq[n]=p[b];b++; //数组q存储着新串}ob1.curLen=len2;for(int l=0; l<len2; l++)ob1.ch[l]=q[l]; //将新串赋值给ob1做循环替换}printf("新串：");for(int h=0; h<ob1.curLen; h++)printf("%c",ob1.ch[h]);}(5)串比较int Compare(HString s1, HString s2){ //若s1<s2则返回值<0; 若s1=s2则返回值=0; 若s1>s2则返回值>0int i;for(i=0; i<s1.curLen&&i<s2.curLen; ++i)if(s1.ch[i]!=s2.ch[i])return (s1.ch[i]-s2.ch[i]);return (s1.curLen-s2.curLen);}四．实验的结果及分析。
数据结构答案串学习指导
第5章串5.1 知识点分析1．串的定义串（String）是由零个或多个任意字符组成的有限序列。
一般记作：s=＂a1 a2 …a i…a n＂。
其中s 是串名，用双引号括起来的字符序列为串值，但引号本身并不属于串的内容。
a i（1<=i<=n）是一个任意字符，它称为串的元素，是构成串的基本单位，i是它在整个串中的序号；n为串的长度，表示串中所包含的字符个数。
2．几个术语（1）长度串中字符的个数，称为串的长度。
（2）空串长度为零的字符串称为空串。
（3）空格串由一个或多个连续空格组成的串称为空格串。
（4）串相等两个串相等，是指两个串的长度相等，且每个对应字符都相等。
（5）子串串中任意连续字符组成的子序列称为该串的子串。
（6）主串包含子串的串称为该子串的主串。
（7）模式匹配子串的定位运算又称为串的模式匹配，是一种求子串的第一个字符在主串中序号的运算。
被匹配的主串称为目标串，子串称为模式。
3．串的基本运算（1）求串长：LenStr(s)。
（2）串连接：ConcatStr(s1,s2) 。
（3）求子串：SubStr (s,i,len)。
（4）串比较：EqualStr (s1,s2)。
（5）子串查找：IndexStr (s,t)，找子串t在主串s中首次出现的位置（也称模式匹配）。
（6）串插入：InsStr (s,t,i)。
（7）串删除：DelStr(s,i,len)。
4．串的存储（1）定长顺序存储。
（2）链接存储。
（3）串的堆分配存储。
5.2 典型习题分析【例1】下面关于串的的叙述中，哪一个是不正确的？（）A．串是字符的有限序列B．空串是由空格构成的串C．模式匹配是串的一种重要运算D．串既可以采用顺序存储，也可以采用链式存储分析：空串是不含任何字符的串，即空串的长度是零。
空格串是由空格组成的串，其长度等于空格的个数。
答案为B。
【例2】两个串相等的充分必要条件是( )。
A．两个串长度相等B．两个串有相同字符C．两个串长度相等且有相同字符D．以上结论均不正确分析：根据串相等定义，两个串是相等是指两个串的长度相等且对应字符都相等，故A、B、C均不正确，答案为D。
第四章串的模式匹配
Sub
S串
ቤተ መጻሕፍቲ ባይዱ
T串
V串
额外定义新串：NewStr，后销毁S并重新赋值
Sub V串 sub V串
结束 上页 下页 末页
节
4.2
串的表示和实现
对字符串常量类似C语言直接以顺序存储方式
存放各字符，末尾加\0,对串变量则要分情况考虑
串的定长顺序存储表示
串的堆分配存储表示
串的块链存储表示
结束 上页 下页 末页
结束 上页 下页 末页
节
Status StrAssign(HString &T, char *chars){ //chars为常量 char *p=chars,q; int i=0; if(T.ch) free(T.ch); while(*p++)i++; //求chars的长度 T.length=i; if (!i) T.ch=NULL; else { T.ch=(char *)malloc(i*sizeof(char)); if (!(T.ch)) exit OVERFLOW; p=chars; q=T.ch; while(*p)*q++=*p++; } return OK; }//注意，p->data当p为NULL时非法
结束 上页 下页 末页
节
Status SubString(SString &Sub, SString S, int pos, int len)
{
int i, j, n; char *p=Sub+1, *q=S+pos ; if (pos<1 || pos>*S) || len<0 || len>*S-pos+1) return ERROR; Sub[1..len]=S[pos..pos+len-1]; //for(i=1;i<=len;++i) *p++=*q++;
第4章 串
表类似，对连接操作方便。
head head A B C E F GH I ∧ I # # #∧
AB CD
中 国 石 油 大 学
4.2
串的链式存储方式的描述
#define CHUNKSIZE 80 typedef struct Chunk {
串的表示和实现
//可由用户定义的块大小 //首先定义结点类型
中 国 石 油 大 学
4.1
串类型的定义
例：求串的定位Index(S,T,pos)。 基本思想：在主串S中取从第i（i的初值为pos）个字符起、 长度和串T相等的子串和串T比较，若相等，则求得函数值
为i，否则i值增1至串S中不存在和串T相等的子串为止。
i
S串
pos
T串
n-m+1
T串
中 国 石 油 大 学
4.1
串类型的定义
例：串的定位Index(S,T,pos) int Index(String S,String T,int pos){
// 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;
体”作为操作对象。
中 国 石 油 大 学
4.1
二、串的基本操作
串类型的定义
串赋值 StrAssign (&T, chars)；把 chars 赋为 T 的值。
字符串的模式匹配
字符串的模式匹配问题描述：如果⼦串T在主串中存在，则返回存在的位置，如果不存在，则返回-1。
1.基本⽅法从主串的第pos位置字符开始和模式⼦串字符⽐较，如果相等，则继续逐个⽐较后续字符；否则从主串的下⼀个字符起再重新和模式⼦串的字符⽐较。
直到找到匹配字符串或者是主串结尾。
伪代码如下：Index(T,S,pos)i <- posj <- 1while i<=length[T] and j<=length[S]if T[i]=S[j]i++j++elsei <- i-j+2j <- 1if j> length[S]return i-lenght[S]elsereturn -1;例如，主串T为：ababcabababab,⼦串为ababa,上述过程如下图所⽰。
源代码如下：/*检测从主串T的pos位置开始，是否有和⼦串S匹配,如果有返回匹配开始位置，如果没有，返回-1T:主串S:⼦串tlength:主串长度slength:⼦串长度pos:主串开始位置*/int Index (char T[],char S[],int tlength,int slength,int pos){int j=0,i=pos;while(i<tlength&&j<slength){if(T[i]==S[j]){i++;j++;}else{i=i-j+1;j=0;}}return j==slength?i-slength:-1;}运⾏结果如下：完成源代码见⽂章最后！2.KMP算法由上述基本⽅法匹配过程中，很多次的⽐较都没有意义的，⽐如当第⼀个主串的c与⼦串中的a不匹配时，下⼀次的主串的b和⼦串的a(第⼀个)的⽐较可以通过分析⼦串的特点直接跳过这次⽐较。
KMP算法就是为了告诉我们，我们应该每当⼀趟匹配过程中出现⽐较不等时，我们不需要回溯i指针。
⽽是利⽤已经得到的“部分匹配”的结果将模式⼦串想右“滑动”尽可能远的距离，然后继续⽐较。
字符串find函数
字符串find函数在编程中，字符串是一种非常常见的数据类型，我们经常需要对字符串进行一些操作，例如查找某个子串在字符串中的位置。
这时，就可以使用字符串find函数。
字符串find函数可以在字符串中查找指定的子串，并返回该子串在字符串中的位置。
下面我们来详细介绍一下字符串find函数的使用方法和注意事项。
一、函数定义字符串find函数的定义如下：int find (const string& str, size_t pos = 0) const noexcept;该函数接受两个参数，第一个参数为要查找的子串，类型为const string&，即一个常量引用，表示字符串；第二个参数为查找的起始位置，类型为size_t，默认值为0，表示从字符串开头开始查找。
该函数返回子串在字符串中的位置，如果没有找到则返回string::npos，即一个特殊的值，表示没有找到。
二、函数示例下面我们来看一个函数示例，该示例演示了如何使用字符串find 函数查找子串在字符串中的位置。
#include <iostream>#include <string>using namespace std;int main(){string str = 'hello world';string sub_str = 'world';size_t pos = str.find(sub_str);if(pos != string::npos){cout << '子串在字符串中的位置为：' << pos << endl;}else{cout << '未找到子串！' << endl;}return 0;}运行结果为：子串在字符串中的位置为：6从上面的程序可以看出，我们首先定义了一个字符串str和要查找的子串sub_str，然后使用字符串find函数查找子串在字符串中的位置，并将结果存储在pos变量中。
locate函数的用法
locate函数的用法概述在Python中，我们经常需要在字符串中查找特定的子字符串。
locate函数就是一种用于在字符串中查找子字符串的函数。
它返回子字符串在字符串中第一次出现的位置，如果未找到该子字符串，则返回-1。
locate()函数的语法如下：`locate(substring, string, start, end)`其中：- substring: 需要查找的子字符串- string: 要查找的字符串- start: 查找的起始位置。
默认为0，如果是负数，则表示从字符串结尾往回数的位置。
- end: 查找的结束位置。
默认为字符串的末尾，如果是负数，则表示从字符串结尾往回数的位置。
如果找到了子字符串，则返回其在字符串中的索引，如果未找到，则返回-1。
例子下面是一个简单的示例，演示如何使用locate()函数来查找子字符串：```# 查找子字符串string = "This is a test string"substring = "test"position = locate(substring, string)print(position) # 10```在上面的示例中，我们定义了一个字符串和一个子字符串，并使用locate()函数来查找子字符串在字符串中的位置。
结果是10，这是子字符串在字符串中的索引。
如果我们指定查找子字符串的起始和结束位置，则函数会在这些位置之间查找子字符串。
```# 查找子字符串的位置string = "This is a test string"substring = "is"position = locate(substring, string, 3, 9)print(position) # -1，因为在指定的位置上未能找到# 查找最后一个出现的子字符串position = locate(substring, string, 0, -6)print(position) # 5```在第一个示例中，由于我们指定的起始和结束位置没有找到子字符串，所以函数返回-1。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机基础知识：串的模式匹配之求子串位置的定位函数【导语】在事业单位考试中，计算机专业知识的复习向来是考生复习备考阶段的一大重点，其中中公事业单位考试网为计算机基础知识的复习为考生提供知识点梳理，帮助考生备考!
在串匹配中，假设S为目标串，P为模式串：
S=‘s1s2...sn’ P=‘p1p2…pm’
串的匹配实际上是根据 1≤i≤n-m+1 依次将 S 的子串 S’[i..i+m-1] 和 P[1..m] 进行比较，若 S’[i..i+m-1] = P[1..m]，则称从位置i开始的匹配成功;反之，匹配失败。
上述的位置i又称为位移，
当S’[i..i+m-1] = P[1..m]时，i称有效位移;
当S’[i..i+m-1]≠ P[1..m]时，i称无效位移。
这样，串匹配问题可简化为是找出某给定模式串 P 在给定目标串 S 中首次出现的有效位移。
以上是中公事业单位考试网为考生梳理计算机基础知识点，供大家学习识记!
中公教育新疆事业单位/xinjiang/。