串
1.定义
字符串,即是由零个或多个字符组成的有限序列,一般记为S='a1a2…an'(n>=0)
。
其中,S是串名,单引号括起来的字符序列是串的值,ai
可以是字母、数字或其他字符;串中字符的个数n称为串的长度,n=0时的串称为空串。
例:S="HelloWorld!"
(Java、C为双引号) T='iPhone 11 pro max?'
(Python为单引号)
子串:串中任意个连续的字符组成的子序列。 主串:包含子串的串。
字符在主串中的位置:字符在串中的序号。
2.基本操作
比较操作StrCompare(S,T)
:若S>T
,则返回值大于0;等于则返回值等于0,小于则返回值小于0。
从第一个字符开始往后依次对比,先出现更大字符的串就更大;
长串的前缀与短串相同时,长串更大。
//比较操作。若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0
int StrCompare(SString S,SString T)
{
for(int i=1;i<=S.length && i<=T.length;i++)
{
if(S.ch[i]!=T.ch[i])
return S.ch[i]-T.ch[i];
}
//扫描过的所有字符都相同,则长度长的串更大
return S.length-T.length;
}
定位操作Index(S,T)
:若主串S中存在与串T值相同的子串,则返回它在主串S中第一次出现的位置,否则函数值为0。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rBJFwa3P-1642574819742)(数据结构学习笔记.assets/image-20220118173205182.png)]
int Index(SString S,SString T)
{
int i=1,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相等的子串
}
3.串的存储结构
(1)顺序存储
静态数组实现:
#define MAXLEN 255 //预定义最大串长为255
typedef struct
{
char ch[MAXLEN]; //每个分量存储一个字符,ch[0]默认不用,优点是字符的位序和数组下标相同
int length; //串的实际长度
}
动态数组实现:(堆分配存储)
typedef struct
{
char *ch;
int length;
}HString;
HString S;
S.ch=(char *)malloc(MAXLEN*sizeof(char)); //用完需要手动free
S.length=0;
(2)链式存储
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5PZMoCfp-1642574819742)(数据结构学习笔记.assets/image-20220118000011643.png)]
typedef struct StringNode
{
char ch; //每个结点存1个字符
string StringNode *next;
}StringNode,*String;
该存储结构存储密度低,每个字符1B,每个指针4B。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X08r3Umo-1642574819743)(数据结构学习笔记.assets/image-20220118000117770.png)]
typedef struct StringNode
{
char ch[4]; //每个结点存多个字符
string StringNode *next;
}StringNode,*String;
该存储结构存储密度提高。
4.字符串模式匹配
(1)朴素模式匹配算法
字符串模式匹配:在主串中找到与模式串相同的子串,并返回其所在位置。
朴素模式匹配算法:将主串中所有长度为m的子串依次与模式串对比,直到找到一个完全匹配的子串,或所有的子串都不匹配为止。(最多对比n-m+1
个子串)(Index定位操作即朴素模式匹配算法)
通过数组下标实现朴素模式匹配算法:
int Index(SString S,SString T)
{
int i=1,j=1;
while(i<=S.length && j<=T.length)
{
if(S.ch[i]==T.ch[j])
{
i++;j++; //继续比较后继字符
}
else
{
i=i-j+2; //指向下一个子串的起始位置
j=1; //指针后退重新开始匹配
}
if(j>T.length)
return i-T.length;
else
return 0;
}
}
设主串长度为n,模式串长度为m,则最坏时间复杂度=O(nm)
,最好时间复杂度=O(n)
。
最坏时间复杂度:每次均为匹配到模式串最后一个字母时发现匹配失败。
在最坏的情况中,每个子串都要对比m个字符,共n-m+1
个子串,复杂度=O((n-m+1)m)
=O(nm)
。(注:很多时候,n远大于m)
在最好的情况中,每个子串的第一个字符就匹配失败,共n-m+1
个子串,复杂度=O(n-m+1)
=O(n)
。
(2)KMP算法
算法分析
算法精髓:利用好已经匹配过的模式串的信息。
int Index_KMP((SString S,SString T,int next[]))
{
int i=1,j=1;
while(i<=S.length&&j<=T.length)
{
if(j==0||S.ch[i]==T.ch[i])
{
i++;j++; //继续比较后继字符
}
else
j=next[j]; //模式串向右移动,i保持不变
if(j>T.length)
return i-T.length;
else
return 0;
}
}
KMP算法的最坏时间复杂度为O(m+n)
,其中,求next数组时间复杂度O(m)
,模式匹配过程最坏时间复杂度O(n)
。
求next数组
next
数组的作用:当模式串的第j
个字符失配时,从模式串的第next[j]
个继续往后匹配。
next[1]、next[2]
在任何情况下均分别为0、1。对于其他的next
,在不匹配的位置前,划一条分界线。模式串一步一步往后退,直到分界线之前“能对上”,或模式串完全跨过分界线为止。此时j指向哪,next
数组值就是多少。
另一种方法是,当此集合不空,且j不等于1时,next[j]
即第j个元素前j-1
个元素首尾重合部分个数再加一。
//通过计算返回子串T的next数组
void get_next(SString T,int *next)
{
int i,k;
i=1,k=0;
next[1]=0;
while(i<T[0])
{
if(k==0||T[i]==T[k])
{
i++;
k++;
next[i]=k;
}
else
k=next[k]; //r
}
}
m个字符,共n-m+1
个子串,复杂度=O((n-m+1)m)
=O(nm)
。(注:很多时候,n远大于m)
在最好的情况中,每个子串的第一个字符就匹配失败,共n-m+1
个子串,复杂度=O(n-m+1)
=O(n)
。
(2)KMP算法
算法分析
算法精髓:利用好已经匹配过的模式串的信息。
int Index_KMP((SString S,SString T,int next[]))
{
int i=1,j=1;
while(i<=S.length&&j<=T.length)
{
if(j==0||S.ch[i]==T.ch[i])
{
i++;j++; //继续比较后继字符
}
else
j=next[j]; //模式串向右移动,i保持不变
if(j>T.length)
return i-T.length;
else
return 0;
}
}
KMP算法的最坏时间复杂度为O(m+n)
,其中,求next数组时间复杂度O(m)
,模式匹配过程最坏时间复杂度O(n)
。
求next数组
next
数组的作用:当模式串的第j
个字符失配时,从模式串的第next[j]
个继续往后匹配。
next[1]、next[2]
在任何情况下均分别为0、1。对于其他的next
,在不匹配的位置前,划一条分界线。模式串一步一步往后退,直到分界线之前“能对上”,或模式串完全跨过分界线为止。此时j指向哪,next
数组值就是多少。
另一种方法是,当此集合不空,且j不等于1时,next[j]
即第j个元素前j-1
个元素首尾重合部分个数再加一。
//通过计算返回子串T的next数组
void get_next(SString T,int *next)
{
int i,k;
i=1,k=0;
next[1]=0;
while(i<T[0])
{
if(k==0||T[i]==T[k])
{
i++;
k++;
next[i]=k;
}
else
k=next[k]; //r
}
}