四、串
1.串的定义
- 串是由零个或多个字符组成的有限序列。串中字符的个数称为串的长度，含有零个元素的串叫空串
- 串中任意连续的字符组成的子序列称为该串的字串，包含字串的串称为主串，某个字符在串中的序号称为这个字符的位置
- 串是限定了元素为字符的线性表
俩个串相等当且仅当这俩个串的长度相等并且对应位置上的字符都相同。一个串中任意个连续字符组成的序列称为该串的子串，
2.串的存储结构
2.1定长顺序存储表示
类似于线性表的顺序存储结构，用一组地址连续的存储单元存储串值的字符序列。在串的定长顺序存储结构中，为每个串变量分配一个固定长度的存储区，即定长数组。
#define MaxSize 100
typedef struct
{
char data[MaxSize];
int length; //串长
} SqString;串的实际长度只能小于或等于 MAXSIZE，超过预定义长度的串值会被舍去，称为截断。串长有两种表示方法:一是如上述定义描述的那样，用一个额外的变量 len 来存放串的长度;二是在串值后面加一个不计入串长的结束标记字符“\0”，此时的串长为隐含值。
在一些串的操作(如插入、联接等》中，若串值序列的长度超过上界 MAXLEN，约定用“截断”法处理，要克服这种弊端，只能不限定串长的最大长度，即采用动态分配的方式。
2.2堆分配存储结构
堆分配存储表示仍然以一组地址连续的存储单元存放串值的字符序列，但它们的存储空间是在程序执行过程中动态分配得到的。
typedef struct
{
char *ch; //按串长分配存储区，ch指向串的基地址
int length; //串长
} SqString;2.3块链存储表示
类似于线性表的链式存储结构，也可采用链表方式存储串值。由于串的特殊性(每个元素只有一个字符)，在具体实现时，每个结点既可以存放一个字符，也可以存放多个字符。每个结点称为块，整个链表称为块链结构。图4.1(a)是结点大小为4(即每个结点存放4个字符)的链表最后一个结点占不满时通常用“#”补上;图4.1(b)是结点大小为1的链表。
3.串的基本操作
StrAssign(&T,chars): 赋值操作。把串T赋值为 chars。
Strcopy(&T,S): 复制操作。由串 S 复制得到串 T。
StrEmpty(S):判空操作。若s 为空串，则返回 TRUE，否则返回FALSE。
StrCompare(S,T):比较操作。若 S>T，则返回值>0;若 s=T，则返回值=0;若 S<T则返回值<0。
StrLength(s):求串长。返回串S的元素个数。
Substring(&Sub,S,pos,Len):求子串。用 Sub 返回串 S 的第pos 个字符起长度为len 的子串。
Concat(&T,s1,s2):串联接。用T返回由 S1和S2联接而成的新串。
Index(S,T):定位操作。若主串 S 中存在与串T 值相同的子串，则返回它在主串 S中第一次出现的位置;否则函数值为 0。
clearString(&s):清空操作。将 S 清为空串。
DestroyString(&S): 销毁串。将串 S 销毁。
不同的高级语言对串的基本操作集可以有不同的定义方法。在上述定义的操作中，串赋值strAssign、串比较 StrCompare、求串长 StrLength、串联接 Concat 及求子串 Substring五种操作构成串类型的最小操作子集，即这些操作不可能利用其他串操作来实现:反之，其他串操作(除串清除 clearstring 和串销毁 Destroystring外)均可在该最小操作子集上实现
3.1顺序串
结构类型
#include <stdio.h>
#define MaxSize 100
typedef struct
{
char data[MaxSize];
int length; //串长
} SqString;赋值
void StrAssign(SqString &s,char cstr[]) //字符串常量赋给串s
{
int i;
for (i=0;cstr[i]!='\0';i++)
s.data[i]=cstr[i];
s.length=i;
}销毁
void DestroyStr(LinkStrNode *&s)
{ LinkStrNode *pre=s,*p=s->next; //pre指向结点p的前驱结点
while (p!=NULL) //扫描链串s
{ free(pre); //释放pre结点
pre=p; //pre、p同步后移一个结点
p=pre->next;
}
free(pre); //循环结束时,p为NULL,pre指向尾结点,释放它
}复制
void StrCopy(SqString &s,SqString t) //串复制
{
int i;
for (i=0;i<t.length;i++)
s.data[i]=t.data[i];
s.length=t.length;
}判断相等
bool StrEqual(SqString s,SqString t) //判串相等
{
bool same=true;
int i;
if (s.length!=t.length) //长度不相等时返回0
same=false;
else
for (i=0;i<s.length;i++)
if (s.data[i]!=t.data[i]) //有一个对应字符不相同时返回0
{ same=false;
break;
}
return same;
}求串长
int StrLength(SqString s) //求串长
{
return s.length;
}串连接
SqString Concat(SqString s,SqString t) //串连接
{
SqString str;
int i;
str.length=s.length+t.length;
for (i=0;i<s.length;i++) //将s.data[0..s.length-1]复制到str
str.data[i]=s.data[i];
for (i=0;i<t.length;i++) //将t.data[0..t.length-1]复制到str
str.data[s.length+i]=t.data[i];
return str;
}求子串
SqString SubStr(SqString s,int i,int j) //求子串
{
SqString str;
int k;
str.length=0;
if (i<=0 || i>s.length || j<0 || i+j-1>s.length)
return str; //参数不正确时返回空串
for (k=i-1;k<i+j-1;k++) //将s.data[i..i+j]复制到str
str.data[k-i+1]=s.data[k];
str.length=j;
return str;
} 插入串
SqString InsStr(SqString s1,int i,SqString s2) //插入串
{
int j;
SqString str;
str.length=0;
if (i<=0 || i>s1.length+1) //参数不正确时返回空串
return str;
for (j=0;j<i-1;j++) //将s1.data[0..i-2]复制到str
str.data[j]=s1.data[j];
for (j=0;j<s2.length;j++) //将s2.data[0..s2.length-1]复制到str
str.data[i+j-1]=s2.data[j];
for (j=i-1;j<s1.length;j++) //将s1.data[i-1..s1.length-1]复制到str
str.data[s2.length+j]=s1.data[j];
str.length=s1.length+s2.length;
return str;
}串删去
SqString DelStr(SqString s,int i,int j) //串删去
{
int k;
SqString str;
str.length=0;
if (i<=0 || i>s.length || i+j>s.length+1) //参数不正确时返回空串
return str;
for (k=0;k<i-1;k++) //将s.data[0..i-2]复制到str
str.data[k]=s.data[k];
for (k=i+j-1;k<s.length;k++) //将s.data[i+j-1..s.length-1]复制到str
str.data[k-j]=s.data[k];
str.length=s.length-j;
return str;
}子串替换
SqString RepStr(SqString s,int i,int j,SqString t) //子串替换
{
int k;
SqString str;
str.length=0;
if (i<=0 || i>s.length || i+j-1>s.length) //参数不正确时返回空串
return str;
for (k=0;k<i-1;k++) //将s.data[0..i-2]复制到str
str.data[k]=s.data[k];
for (k=0;k<t.length;k++) //将t.data[0..t.length-1]复制到str
str.data[i+k-1]=t.data[k];
for (k=i+j-1;k<s.length;k++) //将s.data[i+j-1..s.length-1]复制到str
str.data[t.length+k-j]=s.data[k];
str.length=s.length-j+t.length;
return str;
}输出串
void DispStr(SqString s) //输出串s
{
int i;
if (s.length>0)
{ for (i=0;i<s.length;i++)
printf("%c",s.data[i]);
printf("\n");
}
}3.2链串
结构类型
#include <stdio.h>
#include <malloc.h>
typedef struct snode
{
char data;
struct snode *next;
} LinkStrNode;赋值
void StrAssign(LinkStrNode *&s,char cstr[]) //字符串常量cstr赋给串s
{
int i;
LinkStrNode *r,*p;
s=(LinkStrNode *)malloc(sizeof(LinkStrNode));
r=s; //r始终指向尾结点
for (i=0;cstr[i]!='\0';i++)
{ p=(LinkStrNode *)malloc(sizeof(LinkStrNode));
p->data=cstr[i];
r->next=p;r=p;
}
r->next=NULL;
}销毁
void DestroyStr(LinkStrNode *&s)
{ LinkStrNode *pre=s,*p=s->next; //pre指向结点p的前驱结点
while (p!=NULL) //扫描链串s
{ free(pre); //释放pre结点
pre=p; //pre、p同步后移一个结点
p=pre->next;
}
free(pre); //循环结束时,p为NULL,pre指向尾结点,释放它
}复制
void StrCopy(LinkStrNode *&s,LinkStrNode *t) //串t复制给串s
{
LinkStrNode *p=t->next,*q,*r;
s=(LinkStrNode *)malloc(sizeof(LinkStrNode));
r=s; //r始终指向尾结点
while (p!=NULL) //将t的所有结点复制到s
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;
r->next=q;r=q;
p=p->next;
}
r->next=NULL;
}判断相等
bool StrEqual(LinkStrNode *s,LinkStrNode *t) //判串相等
{
LinkStrNode *p=s->next,*q=t->next;
while (p!=NULL && q!=NULL && p->data==q->data)
{ p=p->next;
q=q->next;
}
if (p==NULL && q==NULL)
return true;
else
return false;
}求串长
int StrLength(LinkStrNode *s) //求串长
{
int i=0;
LinkStrNode *p=s->next;
while (p!=NULL)
{ i++;
p=p->next;
}
return i;
}串连接
LinkStrNode *Concat(LinkStrNode *s,LinkStrNode *t) //串连接
{
LinkStrNode *str,*p=s->next,*q,*r;
str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
r=str;
while (p!=NULL) //将s的所有结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;
r->next=q;r=q;
p=p->next;
}
p=t->next;
while (p!=NULL) //将t的所有结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;
r->next=q;r=q;
p=p->next;
}
r->next=NULL;
return str;
}求子串
LinkStrNode *SubStr(LinkStrNode *s,int i,int j) //求子串
{
int k;
LinkStrNode *str,*p=s->next,*q,*r;
str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
str->next=NULL;
r=str; //r指向新建链表的尾结点
if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))
return str; //参数不正确时返回空串
for (k=0;k<i-1;k++)
p=p->next;
for (k=1;k<=j;k++) //将s的第i个结点开始的j个结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;
r->next=q;r=q;
p=p->next;
}
r->next=NULL;
return str;
}插入串
LinkStrNode *InsStr(LinkStrNode *s,int i,LinkStrNode *t) //串插入
{
int k;
LinkStrNode *str,*p=s->next,*p1=t->next,*q,*r;
str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
str->next=NULL;
r=str; //r指向新建链表的尾结点
if (i<=0 || i>StrLength(s)+1) //参数不正确时返回空串
return str;
for (k=1;k<i;k++) //将s的前i个结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;
r->next=q;r=q;
p=p->next;
}
while (p1!=NULL) //将t的所有结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p1->data;
r->next=q;r=q;
p1=p1->next;
}
while (p!=NULL) //将结点p及其后的结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;
r->next=q;r=q;
p=p->next;
}
r->next=NULL;
return str;
}串删去
LinkStrNode *DelStr(LinkStrNode *s,int i,int j) //串删去
{
int k;
LinkStrNode *str,*p=s->next,*q,*r;
str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
str->next=NULL;
r=str; //r指向新建链表的尾结点
if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))
return str; //参数不正确时返回空串
for (k=0;k<i-1;k++) //将s的前i-1个结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;
r->next=q;r=q;
p=p->next;
}
for (k=0;k<j;k++) //让p沿next跳j个结点
p=p->next;
while (p!=NULL) //将结点p及其后的结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;
r->next=q;r=q;
p=p->next;
}
r->next=NULL;
return str;
}子串替换
LinkStrNode *RepStr(LinkStrNode *s,int i,int j,LinkStrNode *t) //串替换
{
int k;
LinkStrNode *str,*p=s->next,*p1=t->next,*q,*r;
str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
str->next=NULL;
r=str; //r指向新建链表的尾结点
if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))
return str; //参数不正确时返回空串
for (k=0;k<i-1;k++) //将s的前i-1个结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;q->next=NULL;
r->next=q;r=q;
p=p->next;
}
for (k=0;k<j;k++) //让p沿next跳j个结点
p=p->next;
while (p1!=NULL) //将t的所有结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p1->data;q->next=NULL;
r->next=q;r=q;
p1=p1->next;
}
while (p!=NULL) //将结点p及其后的结点复制到str
{ q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
q->data=p->data;q->next=NULL;
r->next=q;r=q;
p=p->next;
}
r->next=NULL;
return str;
}输出串
void DispStr(LinkStrNode *s) //输出串
{
LinkStrNode *p=s->next;
while (p!=NULL)
{ printf("%c",p->data);
p=p->next;
}
printf("\n");
}4串的模式匹配算法
4.1BF算法
BF算法思想:Brute-Force算法又称蛮力匹配算法(简称BF算法),从主串S的第pos个字符开始，和模式串T的第一个字符进行比较，若相等，则继续比较后续字符；否则回溯到主串S的第pos+1个字符开始重新和模式串T进行比较。以此类推，直至模式串T中的每一个字符依次和主串S中的一个连续的字符序列相等，则称模式匹配成功，此时返回模式串T的第一个字符在主串S中的位置；否则主串中没有和模式串相等的字符序列，称模式匹配不成功。
从主串S的第pos个字符开始的子串与模式串T比较的策略是从前到后依次进行比较。因此在主串中设置指示器i表示主串S中当前比较的字符；在模式串T中设置指示器j表示模式串T中当前比较的字符。
穷举法
该算法在最好情况下的时间复杂度为O(m),即主串的前 m 个字符正好等于模式串的 个字符;在最坏情况下的时间复杂度为 O(nXm)。可以证明其平均时间复杂度也是 O(nXm),也就是说,该算法的平均时间性能接近最坏的情况
//BF算法
#include "sqstring.cpp"
int index(SqString s,SqString t)
{
int i=0,j=0;
while (i<s.length && j<t.length)
{
if (s.data[i]==t.data[j]) //继续匹配下一个字符
{
i++; //主串和子串依次匹配下一个字符
j++;
}
else //主串、子串指针回溯重新开始下一次匹配
{
i=i-j+1; //主串从下一个位置开始匹配
j=0; //子串从头开始匹配
}
}
if (j>=t.length)
return(i-t.length); //返回匹配的第一个字符的下标
else
return(-1); //模式匹配不成功
}
int main()
{
SqString s,t;
StrAssign(s,"ababcabcacbab");
StrAssign(t,"abcac");
printf("s:");DispStr(s);
printf("t:");DispStr(t);
printf("位置:%d\n",index(s,t));
return 1;
} 
4.2KMP算法
Knuth-Morris-Pratt算法（简称KMP），是由D.E.Knuth、J.H.Morris和V.R.Pratt共同提出的一个改进算法。KMP算法是模式匹配中的经典算法，和BF算法相比，KMP算法的不同点是消除BF算法中主串S指针回溯的情况，从而完成串的模式匹配，这样的结果使得算法的时间复杂度仅为O(n+m)。
- KMP算法描述
KMP算法每当一趟匹配过程中出现字符比较不相等时，主串S的i指针不需要回溯，而是利用已经得到的“部分匹配”结果将模式串向右滑动一段距离后，继续进行比较 。 - next函数
在实现算法之前，我们需要引入next函数：若令next[j]=k,则next[j]表明当模式中第j个字符与主串中相应字符“失配”时，在模式中需重新和主串中该字符进行比较的当前字符的位置。由此引出next函数的定义： 
由此可见，next函数的计算仅与模式串本身有关，和主串无关。其中’T1T2…T(k-1)'时’T1T2…T(j-1)'的真前缀子串，
‘T(j-k+1)T(j-k+2)…T(j-1)’是’T1T2…T(j-1)'的真后缀子串。当next函数定义中的集合不为空时，next[j]的值等于串’T1T2…T(j-1)'的真前缀子串和真后缀子串相等时的最大子串长度+1
通过以上分析，推导出模式串"abaabcac"的next值的计算过程如下表所示.
(1).当j=1时，由定义得知，next[1]=0;
(2)当j=2时，满足1<k<j的k值不存在，由定义得知next[2]=1;
则我们可以得出next值
匹配过程如下：
在求得模式串的next函数之后，匹配可按如下进行：假设指针i和j分别指示主串S和模式串T中当前比较的字符，令i的初始值为pos,j的初值为1。若在匹配过程中Si=Tj,则i和j分别增1；否则，i不变，而j退到next[j]位置再比较(即Si和Tnext[j]进行比较)，若相等，则指针各自增1，否则j再退到下一个next值得位置，以此类推，直至下列两种可能:
第一种:j退到某个next值(next[…next[j]])时字符比较相等，则指针各自增1继续进行匹配；
第二种是j退到next值为0(即与模式串得第一个字符失配)，则此时需将主串和模式串同时向右滑动一个位置(此时j=0,当向右滑动一个位置时，即模式串得第一个字符)，即从主串得下一个字符Si+1和模式串T1重新开始比较。
//KMP算法
#include "sqstring.cpp"
void GetNext(SqString t,int next[]) //由模式串t求出next值
{
int j,k;
j=0;k=-1;next[0]=-1;
while (j<t.length-1)
{
if (k==-1 || t.data[j]==t.data[k]) //k为-1或比较的字符相等时
{
printf("(1)j=%d,k=%d,两个指向字符相同",j,k);
printf(",执行j++,k++ -> ");
j++;k++;
next[j]=k;
printf("(1) j=%d,k=%d,next[%d]=%d\n",j,k,j,k);
}
else
{
printf("(2)j=%d,k=next[%d]=",j,k);
k=next[k];
printf("%d\n",k);
}
}
}
int KMPIndex(SqString s,SqString t) //KMP算法
{
int next[MaxSize],i=0,j=0;
GetNext(t,next);
while (i<s.length && j<t.length)
{
if (j==-1 || s.data[i]==t.data[j])
{
i++;j++; //i,j各增1
}
else j=next[j]; //i不变,j后退
}
if (j>=t.length)
return(i-t.length); //返回匹配模式串的首字符下标
else
return(-1); //返回不匹配标志
}
/*
int main()
{
SqString s,t;
StrAssign(s,"ababcabcacbab");
StrAssign(t,"abcac");
printf("s:");DispStr(s);
printf("t:");DispStr(t);
printf("位置:%d\n",KMPIndex(s,t));
return 1;
}
*/
int main()
{
SqString s,t;
StrAssign(t,"aaba");
//StrAssign(t,"aaaac");
printf("t:");DispStr(t);
int next[100];
GetNext(t,next);
return 1;
}
4.3改进KMP算法
我们在前面介绍的next函数虽然好用，但还不够完美，在某种情况下是有缺陷的，例如如下匹配过程
主串为"aaabaaaab" 模式串为"aaaab"
从串的匹配过程可以看到，当i=4，j=4时，S4!=T4,由next[j]所示还需进行i=4、j=3,i=4、j=2,i=4、j=1这三次比较。实际上，因为模式串中的第1、2、3个字符和第4个字符都相等(即都是’a’)，因此，不需要再和主串中第4个字符相比较，而可以直接将模式串一次向右滑动4个字符的位置直接进行i=5、j=1的判断。
这就是说，若按上述定义得到next[j]=k,而模式串中T(j)!=T(k),则当Si != Tj时，不需要进行Si和Tk的比较，直接和Tnext[k]进行比较；换句话说，此时的next[j]的值应和next[k]相同，为此将next[j]修正为nextval[j]。而模式串中Tj !=Tk,则当Si !=Tj时，还是需要比较Si和Tk的比较，因此nextval[j]的值就是k,即nextval[j]得值就是next[j]的值。
通过以上分析，计算第j个字符得nextval值时，要看第j个字符是否和第j个字符的next值指向的字符相等。若相等，则nextval[j]=nextval[next[j]]；否则，nextval[j]=next[j]。
由此推导出模式串T='aaaab’的nextval值的计算过程如下:
当j=1时，由定义知，nextval[1]=0;
当j=2时，由next[2]=1,且T2=T1,则nextval[2]=nextval[1],即nextval[2]=0;
当j=3时，由next[3]=2,且T3=T2,则nextval[3]=nextval[2],即nextval[3]=0;
当j=4时，由next[4]=3,且T4=T3,则nextval[4]=nextval[3],即nextval[4]=0；
当j=5时，由next[5]=4,且T5不等于T4,则nextval[5]=next[5],即nextval[5]=4.
则模式串"aaaab"的nextval函数值如下所示。
改进后
- 可以看到匹配次数大大减少，降低了复杂度。
- nextval函数实现代码如下
nextval[]时基于next[]函数实现的。
通常，模式串的长度m比主串的长度n小很多，且计算next或者nextval函数的时间复杂度为O(m)。因此，对于整个匹配算法来说，所增加的计算next或nextval时值得的。
BF算法的时间复杂度为O(m*n),但是实际接近于O(n+m),因此至今仍被采用。KMP算法仅当模式串与主串之间存在许多“部分匹配”的情况下，才会比BF算法快。KMP算法的最大特点就是主串的指针不需要回溯，整个匹配过程中，主串仅需从头到尾扫描一次，对于处理从外设输入的庞大文件很有效，可以边读边匹配。
扫一扫
5510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
