第四章——串
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了第四章——串相关的知识，希望对你有一定的参考价值。
参考技术A 串，即字符串（String）是由零个或多个字符组成的有限序列。一般记为S = ‘a1a2······an' （n ≥0）其中，S是串名，单引号括起来的字符序列是串的值；ai可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n = 0时的串称为空串（用∅表示）。S=”HelloWorld!”
T=‘iPhone 11 Pro Max?’
子串：串中任意个连续的字符组成的子序列。 Eg：’iPhone’，’Pro M’ 是串T 的子串。
主串：包含子串的串。 Eg：T 是子串’iPhone’的主串。
字符在主串中的位置：字符在串中的序号。 Eg：’1’在T中的位置是8(第一次出现)
子串在主串中的位置：子串的第一个字符在主串中的位置 。 Eg：’11 Pro’在 T 中的位置为8
串是一种特殊的线性表，数据元素之间呈线性关系。
串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）
串的基本操作，如增删改查等通常以子串为操作对象。
假设有串T=“”，S=”iPhone 11 Pro Max?”，W=“Pro”
StrAssign(&T,chars)：赋值操作。把串T赋值为chars。
StrCopy(&T,S)：复制操作。由串S复制得到串T。
StrEmpty(S)：判空操作。若S为空串，则返回TRUE，否则返回FALSE。
StrLength(S)：求串长。返回串S的元素个数。
ClearString(&S)：清空操作。将S清为空串。
DestroyString(&S)：销毁串。将串S销毁（回收存储空间）。
Concat(&T,S1,S2)：串联接。用T返回由S1和S2联接而成的新串
SubString(&Sub,S,pos,len)：求子串。用Sub返回串S的第pos个字符起长度为len的子串。
Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的
位置；否则函数值为0。
StrCompare(S,T)：比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0。
串的模式匹配：在主串中找到与模式串相同的子串，并返回其所在位置。
Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0。
若模式串长度为m，主串长度为n，则
匹配成功的最好时间复杂度：O(m)
匹配失败的最好时间复杂度：O(n-m+1) = O(n-m)≈O(n)
若模式串长度为m，主串长度为n，则直到匹配成功/匹配失败最多需要 (n-m+1)*m 次比较
最坏时间复杂度：O(nm)
串的模式匹配：在主串中找到与模式串相同的子串，并返回其所在位置。
朴素模式匹配算法（简单模式匹配算法）思想：
将主串中与模式串长度相同的子串搞出来，挨个与模式串对比
当子串与模式串某个对应字符不匹配时，就立即放弃当前子串，转而检索下一个子串
若模式串长度为m，主串长度为n，则直到匹配成功/匹配失败最多需要 (n-m+1)*m 次比较
最坏时间复杂度：O(nm)
最坏情况：每个子串的前m-1个字符都和模式串匹配，只有第m个字符不匹配
比较好的情况：每个子串的第1个字符就与模式串不匹配
简单模式匹配算法的最坏情况：若模式串长度为m，主串长度为n，则直到匹配成功/匹配失败最多需要 n*m 次比较最坏时间复杂度：O(nm)
朴素模式匹配算法的缺点：当某些子串与模式串能部分匹配时，主串的扫᧿指针 i 经常回溯，导致时间开销增加。
改进思路：主串指针不回溯，只有模式串指针回溯。
朴素模式匹配算法的缺点：当某些子串与模式串能部分匹配时，主串的扫描指针 i 经常回溯，导致时间开销增加。最坏时间复杂度O(nm)
KMP算法：当子串和模式串不匹配时，主串指针 i 不回溯，模式串指针 j=next[j]
算法平均时间复杂度：O(n+m)
如果不会经常出现子串与模式串部分匹配问题，那么KMP算法也没屌多少
next数组手算方法：当第j个字符匹配失败，由前 1~j-1 个字符组成的串记为S，则：next[j]=S的最长相等前后缀长度+1
特别地，next[1]=0
nextval数组的求法：
先算出next数组
先令nextval[1]=0
for (int j=2; j<=T.length; j++)
if(T.ch[next[j]]==T.ch[j])
nextval[j]=nextval[next[j]];
else
nextval[j]=next[j];
KMP算法优化：当子串和模式串不匹配时j=nextval[j];
第四章：2.串 -- 串的模式匹配算法（KMP）
前言：
目录：
1.串类型的定义
2.串的表示和实现
3.串的模式匹配算法
4.串操作应用举例
正文：
串的模式匹配即，在给定主串S 中，搜索子串T 的位置，如果存在T 则返回其所在位置，否则返回 0
串的模式匹配算法
主串 S: a b c a b c d s v t
子串 T: a b c d
一、原始算法
匹配一旦失败，子串即向右移动一个单位，直到完全匹配停止。
第一次匹配：（注：红色代表不匹配（失配））
S: a b c a b c a b c d s v t
T: a b c d
第二次匹配：
S: a b c a b c d s v t
T: a
代码实现：（在 上一节已经实现的堆分配存储结构的基础 上实现）
//模式匹配（子串定位通常称为模式匹配） //求主串S 第 pos 个字符之后,与模式串 T 相等的位置 int Index(HString S,HString T,int pos){ int i=pos; int j=0; //没有到主串末尾 while(i<S.length){ if(S.ch[i]==T.ch[j]){ //如果子串已经匹配结束，那么返回主串S 中开始匹配的位置 if(j+1==T.length) return i-j+1; //否则继续往后比较 i++; j++; }else{ //存在字符不相等，i指向主串S 当前开始匹配位置的下一位。 j 在子串中重头开始 i=i-j+1; j=0; } } //匹配失败 return 0; }
运行结果：
匹配位置： 7 、比较总次数：16次
二、算法的第一次改进
第一次匹配：
下标: 0 1 2 3
S[i]: a b c a b c a b c d s v t
T[j]: a b c d
原始算法中，第一次匹配时，在i=3, j=3 时，a <> b。这时发现将 T 向右移动一个位置 和 自动两个位置都是没有必要的。这时我们在第二次匹配时，直接将子串 T 向右移动 3 个位置即可。
第二次匹配：
S: a b c a b c a b c d s v t
T: a b c d
T之所以可以向右移动 3 个位置，是因为 在 已匹配的位置 a b c 中, b c 和 a 不相等，所有串不可能匹配起来。
总结如下：
当已匹配的串中（包含n个字符）
1.除首个字符外，不存在字符和首字符相等，那么子串 T 应向右移动 n-1个位置
2.如果存在 和首字符相等的元素 Tj，那么应该把子串 T 向右移动 j 个位置
因此，一旦子串确定，我们就可以确定当子串T 中的 Tj 和主串S 中的Si 匹配失败时，子串应该移动的位置。此时，我们只需要把注意力放在子串T 上即可。
以上面子串T 为例，设step[j] 为比较到T[j] 匹配失败时，子串T 应该向右移动的位置长度。
下标j: 0 1 2 3
T[j]: a b c d
step[j]: 1 1 2 3
综上所述，只要子串T 确定， step[j] 数组就可以被确定。那么推广到一般情况，我们通过函数构造 step数组的算法如下。
//构造step数组 int *next; void InitStep(HString T){ int *step; step=(int *)malloc(T.length*sizeof(int)); if(!step) exit(OVERFLOW); step[0]=1; int equalPos=0; //记录和首字符相等的字符首次出现的位置，为0说明不存在 for(int i=1;i<T.length;i++){ if(T.ch[i]==T.ch[0]){ //记录出现位置 if(equalPos==0) equalPos=i; step[i]=i; }else{ if(equalPos==0){ step[i]=i; }else{ step[i]=equalPos; } } } next=step; }
此时，只需将 原始的模式匹配算法中 步长增1 改为 增step[j] 如下
//存在字符不相等，i指向主串S 当前开始匹配位置的下一位。 j 在子串中重头开始
i=i-j+1; （改为：i=i-j+next[j]; ）
j=0;
算法即得到改进。
运行结果：
匹配位置： 7 、比较总次数：12次
当主串数据量增大时，此改进后的算法的优势会越来越明显。
三、算法的第二次改进即（KMP算法）
假设此时的主串和子串为：
S[i]: a b c r a b c a b c d s v t
T[j]: a b c r a b c d
第一次匹配：
下标: 0 1 2 3 4 5 6 7
S[i]: a b c r a b c s a b c r a b c d s v t
T[j]: a b c r a b c d
如果根据第一次改进的算法将会得到step:
下标j: 0 1 2 3 4 5 6 7
T[j]: a b c r a b c d
step[j]: 1 1 2 3 4 4 4 4
可得第一次匹配失败时，step[7]=4，那么子串T 向右移动4 个长度的位置开始第二次匹配， 从主串的第4个下标开始比较，即 S[4]=a 开始比较。
第二次匹配：
下标: 0 1 2 3 4 5 6 7
S: a b c r a b c s a b c r a b c d s v t
T: a b c r a b c d
但是我们发现：
下标4,5,6 对应的a,b,c。这三次比较也是没有必要进行的。
即第二次匹配，我们仅仅需要令 S[7]=s 和 T[3]=r 开始比较即可。
分析：
之所以可以从 子串T 的第4 个字符开始进行比较，而不需要比较前3 个字符。是因为T[0，1，2] 分别等于 S[4，5，6]，又因为在第一次匹配过程中，S[7]失配的时候，已匹配字符序列为：T[0，1，2，3，4，5，6] = S[0，1，2，3，4，5，6]，可知：
T[0，1，2，3，4，5，6] = S[0，1，2，3，4，5，6] 可知 T[4，5，6] = S[4，5，6]
又T[0，1，2] = S[4，5，6]
因此有：T[0，1，2] = S[4，5，6] =T[4，5，6]
在子串T 中: a b c r a b c d 中失配字符 d前面的子串sub:a b c r a b c，其前缀等于后缀（即两端相等）。
总结，在 S[i] 、T[j] 的匹配过程中，当 S[i] 不等于 T[j] 时，在已匹配的串 T[0，1，...，j-1]中 其前缀等于后缀，那么下一次匹配只需要将其前缀和 上次后缀对其即可，然后从匹配前缀的下一位置和主串继续比较，S[7]=d 和 T[3]=r进行比较。那么当前 主串下标 i=7 ，子串下标 j=3。我们设此时的子串下标为 k。
那么此时有：
T[0，1，...，k-1] = T[j-k，...，j-1] 长度为 k 且 0<k<j-1
下标: 0 1 2 3 4 5 6 7
S[i]: a b c r a b c s a b c r a b c d s v t
第一次匹配： T[j]: a b c r a b c d
第二次匹配： T[j]: a b c r a b c d
这时，我们发现，只要子串确定，我们就可以确定当 T 在 j 出失配的时候，S[i] 应该继续和下标为k 的T 继续比较。
推广到一般情况：
设当 主串S 和子串T 失配的时候，下标分别为 i 和 j。
1、当已匹配的串存在前缀 = 后缀，那么我们保持 i 不变，让S[i] 和 T[k]继续往下比较即可。
2、当已匹配的串不存在 前缀 = 后缀的情况
如果T[j] 不是T 的第一个字符，那么 S[i] 应该和 T 的第一个元素开始比较，此时 k=0
如果T[j] 是T 的第一个字符， 那么 i 后移一位，和 T的第一元素开始比较，即S[++j] 和 T[0] 开始比较，我们规定此时 k = -1
如上所述，我们设主串S[i] 和子串T[j]失配时，pos[j]=k。
此时模式匹配算法实现如下：
int KMP(HString S,HString T,int position){ int i=position; int j=0; o=0; //没有到主串末尾 while(i<S.length){ o++; if(S.ch[i]==T.ch[j]){ //如果子串已经匹配结束，那么返回主串S 中开始匹配的位置 if(j+1==T.length) return i-j+1; //否则继续往后比较 i++; j++; }else{ //i,j失配 if(pos[j]==-1){ i++; j=0; }else{ j=pos[j]; } } } //匹配失败 return 0; }
如上模式匹配算法已经实现，现在需要做的就是来实现 pos[j] 数组。
pos:
下标j: 0 1 2 3 4 5 6 7
T[j]: a b c r a b c d
pos[j]: -1 0 0 0 0 1 2 3
假设 pos[j]=k 成立，则对于已匹配部分：T[0，...，j-1] 有
如果T[j] = T[k]，即T[0，...，k-1，k] = T[j-k，...，j-1，j] 那么 pos[j+1] = k+1 =pos[j] + 1
如果T[j] <> T[k]
以上是关于第四章——串的主要内容，如果未能解决你的问题，请参考以下文章