目录
一.串定义与基本操作
1.1.串的定义
串，即字符串（String）是由零个或多个字符组成的有限序列。一般记为
S = ‘a1a2······an' （n ≥0）
其中，S是串名，单引号（双引号）括起来的字符序列是串的值；ai可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n = 0时的串称为空串（用∅表示）。
例:
S=”HelloWorld!”
T=‘iPhone 11 Pro Max?’
子串：串中任意个连续的字符组成的子序列。
主串：包含子串的串。
字符在主串中的位置：字符在串中的序号。
串在主串中的位置：子串的第一个字符在主串中的位置 。
空串 V.S空格串：
注：与线性表相似
1.2.串的基本操作
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。
1.从第一个字符开始往后依次对比，先出现更大字符的串就更大 。
2.长串的前缀与短串相同时，长串更大。
3.只有两个串完全相同时，才相等。
二.串的存储结构
2.1串的顺序存储
#define MAXLEN 255; //预定义最大串为255
// 静态数组实现（定长顺序存储）
typedef struct{
char ch[MAXLEN]; //每个分量存储一个字符
int length; //串的实际长度
}SString;
// 动态数组实现（堆分配存储）
tyepdef struct{
char *ch; //按串长分配存储区，ch指向串的基地址
int length //串的长度
}HString;
Hstring S;
S.ch = (char *)malloc(MAXLEN * sizeof(char)); //用完需要手动free
S.length==0;方案一：专门申请length
方案二：ch[0]充当length，优点：字符的位序和数组下标相同
方案三：没有Length变量，以字符’\0'表示结尾（对应ASCIl码的 0)，需要从头到尾扫描，扫描到‘\0’才能得到字符串的长度
方案四：ch[0]废弃不用，专门申请length
2.2串的链式存储
typedef struct StringNode{
char ch; //每个结点存放1个字符
struct StringNode *next;
}StringNode,*String;一个char的大小为1B，但是在32位计算机中，指针大小为4B，这就表示我们在存储一个字符时，只用了1B存储实际需要存储的信息，用了4B存储了辅助信息。这样存储密度就太低了。
typedef struct StringNode{
char ch[4]; //每个结点存多个字符
struct StringNode *next;
}StringNode, *String;
如图，最后一个结点如果存不满，用字符填充
3.3 串的基本操作
3.3.1 求子串
SubString(&Sub,S,pos,len)：求子串。用Sub返回串S的第pos个字符起长度为len的子串。
#define NAXLEN 255;
typedef struct{
char ch[MAXLEN];
int length;
}SString;
// 求子串
bool SubString(SString &Sub, SString S, int pos, int len){
if(pos+len-1<S.length)
return false;
for(int i=pos;i<pos+len;i++)
Sub.ch[i-pos+1]=S.ch[i];
Sub.length = len;
return true;
}3.3.2 比较串的大小
StrCompare(S,T)：比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0。
图中返回1
//比较操作，若S>T，则返回值>0，若S=T，则返回值=0，若S<T，则返回值<0
int StrCompare(SString S,SStromg T){
for(int i=0; i<S.length&&i<T.length; i++){
if(S.sh[i]!=T.sh[i])
return S.sh[i]-S.sh[j];
}
//扫描过的所有字符都相同，则长度长的字符串大
return S.length-T.length;
}3.3.3 定位操作
Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串s中第一次出现的
位置；否则函数值为0。
int Index(SString S,SString T){
int i=0,n=StrLength(S), m=StrLength(T);
SString sub； //用于暂时存储子串
while(i<n-m+1){
SubString(sub,S,i,m);
if(StrCompare(sub,T)!=0)
i++;
else
return i; //返回子串在主串的位置
}
return 0; //S中不存在与T相等的子串
}
// 串长
int StrLength(SString S){
return S.length;
}
//求子串
bool SubString(SString &Sub, SString S, int pos,int len){
if(pos+len-1>S.length)
return false;
for(int i=pos, i<S.length,i++)
Sub.sh[i-pos+1]=S.sh[i];
Sub.length=len;
return false;
}
//比较串大小
int StrCompare(SString S,SString T){
for(int i=0;i<S.length&&i<T.length;i++){
if(S.sh[i]!=T.sh[i])
return S.sh[i]-T.sh[i];
}
return S.length-T.length;
}三.字符串的模式匹配
3.1 朴素模式匹配算法
什么是模式匹配？
在主串中找到与模式串相同的⼦串，并返回其所在位置。
子串：主串的一部分，一定存在
模式串：不一定在主串中找到
若主串长度为n，模式串长度为 m，将主串中所有长度为m的子串依次与模式串对比，直到找到一个完全匹配的子串或所有的子串都不匹配为止。度为n的主串中，最多有n-m+1个子串
若匹配失败，如上图所示，则主串指针 i 指向下一个子串的第一个位置，模式串指针 j 回到模式串的第一个位置。
只需要改变i，j指针的指向，就可以完成以上操作。
i=i-j+2; // i-(j-1)相当于i回到开始的位置,再加1就是下一个字符串
j=1; // j-(j-1)就相当于回到了1
若j>T.length（j指向的位置超出了模式串的长度），则当前子串匹配成功，返回当前子串第一个字符的位置 ---- i-T.length
int Index(SString S,SString T){
int i=1,j=1;
while(i<S.length && j<T.length){
if(S.ch[i]==T.sh[j]){
++i;
++j;
}else{
i=i-j+2;
j=1;
}
}
if(j>T.length)
return i-T.length;
else
return 0;
}设主串长度为n，模式串长度为m，每个子串都要对比 m 个字符，共 n-m+1 个子串，复杂度=O((n-m+1)m) = O(nm-m^2+m) = O(nm)，通常情况下n>>m
那么最坏时间复杂度=O(nm)
3.2 KMP算法
重点思考
以模式串abaabc为例
1.当第6个元素匹配失败时：
模式串向后移动，i不变。（j--，i不变） 直到移动到说不定匹配情况，如下图：
结论：当第6个元素匹配失败时，可令主串指针 i 不变，模式串指针 j=3
2.当第5个元素匹配失败时：
模式串向后移动，i不变。（j--，i不变） 直到移动到说不定匹配情况，如下图：
结论：当第5个元素匹配失败时，可令主串指针 i 不变，模式串指针 j = 2
3.当第4个元素匹配失败时：
模式串向后移动，i不变。（j--，i不变） 直到移动到说不定匹配情况，如下图：
结论：当第4个元素匹配失败时，可令主串指针 i 不变，模式串指针 j = 2
4.当第3个元素匹配失败时：
模式串向后移动，i不变。（j--，i不变） 直到移动到说不定匹配情况，如下图：
结论：当第3个元素匹配失败时，可令主串指针 i 不变，模式串指针 j = 1
5.当第2个元素匹配失败时：
模式串向后移动，i不变。（j--，i不变） 直到移动到说不定匹配情况，如下图：
结论：当第2个元素匹配失败时，可令主串指针 i 不变，模式串指针 j = 1
6.当第1个元素匹配失败时：
模式串向后移动，i也向后移动。（j=0， i++, j++） 直到移动到说不定匹配情况，如下图：
结论：匹配下⼀个相邻⼦串，令 j=0, i++, j++
整体总结：
当第6个元素匹配失败时，可令主串指针 i 不变，模式串指针 j=3
当第5个元素匹配失败时，可令主串指针 i 不变，模式串指针 j=2
当第4个元素匹配失败时，可令主串指针 i 不变，模式串指针 j=2
当第3个元素匹配失败时，可令主串指针 i 不变，模式串指针 j=1
当第2个元素匹配失败时，可令主串指针 i 不变，模式串指针 j=1
当第1个元素匹配失败时，匹配下⼀个相邻⼦串，令 j=0, i++, j++从而得出next数组
int Index_KMP(SString S,SString T,int next[]){
int i=0,j=0;
//循环遍历
while(i<S.length && j<T.length){
if(j==0 || S.ch[i]==T.sh[j]){
++i;
++j; //继续比较后继字符
}else
j=next[j]; //模式串向右移动
}
if(j>T.length)
return i-T.length; //匹配成功
else
return 0;
}KMP算法，最坏时间复杂度 O(m+n)
其中，求 next 数组时间复杂度 O(m)
模式匹配过程最坏时间复杂度 O(n)
3.3 求next数组
求next数组参考 3.2重点思考，以模式串abaabc为例.
练习1:写出google的next数组
注：next[1] 直接填0，next[2]直接填1。
练习2:模式串 T = ababaa
3.4 KMP算法的进一步优化
重点思考:
1.当j=3时不匹配
j=3 指向a,因为不匹配,所以i=3指向不是a.
j=3 通过next数组指向 1;
因为j=1 指向的也为a, i=3本来不是a. 所以next[3] 改成直接next[1],也就是0
2.当j=4时不匹配
j=4 指向a,因为不匹配,所以i=4指向不是a.
next数组指向j=2,也就是b, 所以不能更改
最终
练习
模式串 T = ababaa
注:
nextval[1]=0;
如果j指向的字符与next[j]所指的字符相同nextval[j]=nextval[next[j]];
例如上图，j=3时，j所指的字符是a，其next[3]所指的字符也是a，那么就让nextval的值优化为next[1]的值0。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
