数据结构——串（基础知识）_串的连接操作的时间复杂度通常是-CSDN博客

ADT (string)
Data
//串中元素仅由一个字符组成，相邻元素具有前驱和后继的关系
Operation
StrAssign(T,*chars)://生成一个其值等于字符串常量chars的串T
StrCopy(T,S)://串s纯在。有串S赋值得串T
ClearString(S)://串S存在，将串清空
StringEmpty(S)://若串为空，返回true,否则返回false
StrLength(S)://返回串S的元素个数，即串的长度
StrCompare(S,T)://若S>T，返回值>0,若S=T，返回0，若S<T，返回值<0
Concat(T,S1,S2)://用T返回由s1和s2连接而成的新串
SubString(Sub,S,pos,len)://串S存在，1<=pos<=StrLength(S),且0<=len<=StrLength(S)-pos+1,用Sub
//返回串S的第pos个字符起长度为len的子串
Index(S,T,pos)://串S和T存在，T是非空串，1<=pos<=StrLength（S)，若主串S中存在和串T值相同的子串
//则返回它在主串S中第pos个字符之后第一次出现的位置，否则返回
Replace(S,T,V)://串S、T和V存在，T是非空串。用V替换主串S中出现的所有与T相等的不重叠的子串
StrInsert(S,pos,T)://串S和T存在，1<=pos<=StrLength(S)+1,zai 串S的第pos个字符之前插入串T
StrDelete(S,pos,len)://串S存在，1<=pos<=StrLength(S)-len+1,从串S中删除第pos个字符起长度为len的子串

对于不同高级语言，其实对串的基本操作会有不同的定义方法，不过还好，不同语言除方法名称外，操作是指都是类似的

Index的实现算法

//T为非空串，若主串S中第pos个字符之后存在与T相等的子串
//则返回第一个这样子串在S中的位置，否则返回0
int Index(String S,String T,int pos)
{
int n,m,i;
String sub;
if(pos>0)
{
n=StrLength(S);//得到主串S的长度
m=StrLength(T)://得到子串T的长度
i=pos;
while(i<=n-m+1)
{
SubString(sub,S,i,m);//取主串中第i个位置开始长度与T相等的子串给sub
if(StrCompare(sub,T)!=0)//两串不相等
++i；
else
return i;
}
}
return 0;
】

串的存储结构

串的存储结构与线性表相同，分为两种。

串的顺序存储结构：

串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列的。

“\0”为结束字符，不算入字符串长度

对于串的顺序存储，有一些变化，串值的存储空间可在执行程序过程中分配而得。比如在计算机中存一个自由存储区，叫做“堆”。这个堆可由C语言的动态分配函数，malloc（）和free（）来管理

串的链式存储结构：

对于串的链式存储结构，与线性表相似，到由于串结构的特殊性，结构中的每个元素数据是一个字符，如果简单得应用链表存储串值，就会存在很大的空间浪费，因此，可以一个结点放多个字符，若一个结点未被占满可用“#”来填补

朴素的模式匹配算法

子串的定位操作通常称做串的模式匹配，是串中最重要的操作之一

假设我们要从下面的主串S=“goodgoogle”中，找到T=“google”这个子串的位置，操作如下：

（1）主串S第一位开始，S与T前三个字母匹配成功，但S第四个字母是d而T的是g。第一位匹配失败

（2）主串S第二位开始，主串S首字母是o，要匹配的T首字母是g，匹配失败

（3）主串S第三位开始，主串S首字母o，要匹配的T首字母是g，匹配失败

（4）主串S第四位开始，主串S首字母是d，要匹配的T首字母是g，匹配失败

（5）主串S第五位开始，S与T，6个字母全匹配，匹配成功

简单来说：就是每读取一个主串的字符便对子串进行一次循环，直至匹配成功

现在用基本的数组操作来实现匹配算法：（长度存在S[0]与T[0]中）

//返回子串T在主串S中第pos个字符之后的位置，若不存在，则函数返回0
//其中，T非空，1<=pos<=StrLength(S)
int Index(String S,String T,int pos)
{
int i=pos;//i用于主串S中当前位置下标值，从pos位置开始匹配
int j=1;//j用于子串T中当前位置下标值
while(i<=S[0]&&j<=T[0]){//当i小于S的长度并且j小于T的长度时，循环继续
if(S[i]==T[j])//量字母相等则继续
{
++i;
++j;
}
else//指针后退重新开始匹配
{
i=i-j+2;//i退回到上次匹配收尾的下一位
j=1;//j退回到子串T的首位
}
if(j>T[0])
return i-T[0];
else
return 0;
}

分析一下：

最好的情况：

一开始就匹配成功，则时间复杂度为O(m)

最坏的情况：

到最后才匹配成功，则时间复杂度为O(m+n)

在数据量多的时候，如此繁琐的算法就显得太低效了