数据结构习题集答案C语言版严蔚敏第四章 串.docx

数据结构习题集答案C语言版严蔚敏第四章 串.docx

《数据结构习题集答案C语言版严蔚敏第四章 串.docx》由会员分享，可在线阅读，更多相关《数据结构习题集答案C语言版严蔚敏第四章 串.docx（12页珍藏版）》请在冰豆网上搜索。

数据结构习题集答案C语言版严蔚敏第四章串

第四章串

4.10

voidString_Reverse（Stringtypes,Stringtype&r）//求s的逆串r

{

StrAssign（r,''）;//初始化r为空串

for（i=Strlen（s）;i;i--）

{

StrAssign（c,SubString（s,i,1））;

StrAssign（r,Concat（r,c））;//把s的字符从后往前添加到r中

}

}//String_Reverse

4.11

voidString_Subtract（Stringtypes,Stringtypet,Stringtype&r）//求所有包含在串s中而t中没有的字符构成的新串r

{

StrAssign（r,''）;

for（i=1;i<=Strlen（s）;i++）

{

StrAssign（c,SubString（s,i,1））;

for（j=1;j

if（i==j）

{

for（k=1;k<=Strlen（t）&&StrCompare（c,SubString（t,k,1））;k++）;//判断当前字符是否包含在t中

if（k>Strlen（t））StrAssign（r,Concat（r,c））;

}

}//for

}//String_Subtract

4.12

intReplace（Stringtype&S,StringtypeT,StringtypeV）;//将串S中所有子串T替换为V,并返回置换次数

{

for（n=0,i=1;i<=Strlen（S）-Strlen（T）+1;i++）//注意i的取值范围

if（!

StrCompare（SubString（S,i,Strlen（T））,T））//找到了与T匹配的子串

{//分别把T的前面和后面部分保存为head和tail

StrAssign（head,SubString（S,1,i-1））;

StrAssign（tail,SubString（S,i+Strlen（T）,Strlen（S）-i-Strlen（T）+1））;

StrAssign（S,Concat（head,V））;

StrAssign（S,Concat（S,tail））;//把head,V,tail连接为新串

i+=Strlen（V）;//当前指针跳到插入串以后

n++;

}//if

returnn;

}//Replace

分析:

i+=Strlen（V）;这一句是必需的,也是容易忽略的.如省掉这一句,则在某些情况下,会引起不希望的后果,虽然在大多数情况下没有影响.请思考:

设S='place',T='ace',V='face',则省掉i+=Strlen（V）;运行时会出现什么结果?

4.13

intDelete_SubString（Stringtype&s,Stringtypet）//从串s中删除所有与t相同的子串,并返回删除次数

{

for（n=0,i=1;i<=Strlen（s）-Strlen（t）+1;i++）

if（!

StrCompare（SubString（s,i,Strlen（t））,t））

{

StrAssign（head,SubString（S,1,i-1））;

StrAssign（tail,SubString（S,i+Strlen（t）,Strlen（s）-i-Strlen（t）+1））;

StrAssign（S,Concat（head,tail））;//把head,tail连接为新串

n++;

}//if

returnn,

}//Delete_SubString

4.14

StatusNiBoLan_to_BoLan（Stringtypestr,Stringtype&new）//把前缀表达式str转换为后缀式new

{

Initstack（s）;//s的元素为Stringtype类型

for（i=1;i<=Strlen（str）;i++）

{

r=SubString（str,i,1）;

if（r为字母）push（s,r）;

else

{

if（StackEmpty（s））returnERROR;

pop（s,a）;

if（StackEmpty（s））returnERROR;

pop（s,b）;

StrAssign（t,Concat（r,b））;

StrAssign（c,Concat（t,a））;//把算符r,子前缀表达式a,b连接为新子前缀表达式c

push（s,c）;

}

}//for

pop（s,new）;

if（!

StackEmpty（s））returnERROR;

returnOK;

}//NiBoLan_to_BoLan

分析:

基本思想见书后注释3.23.请读者用此程序取代作者早些时候对3.23题给出的程序.

4.15

voidStrAssign（Stringtype&T,charchars&#;）//用字符数组chars给串T赋值,Stringtype的定义见课本

{

for（i=0,T[0]=0;chars[i];T[0]++,i++）T[i+1]=chars[i];

}//StrAssign

4.16

charStrCompare（Stringtypes,Stringtypet）//串的比较,s>t时返回正数,s=t时返回0,s

{

for（i=1;i<=s[0]&&i<=t[0]&&s[i]==t[i];i++）;

if（i>s[0]&&i>t[0]）return0;

elseif（i>s[0]）return-t[i];

elseif（i>t[0]）returns[i];

elsereturns[i]-t[i];

}//StrCompare

4.17

intString_Replace（Stringtype&S,StringtypeT,StringtypeV）;//将串S中所有子串T替换为V,并返回置换次数

{

for（n=0,i=1;i<=S[0]-T[0]+1;i++）

{

for（j=i,k=1;T[k]&&S[j]==T[k];j++,k++）;

if（k>T[0]）//找到了与T匹配的子串:

分三种情况处理

{

if（T[0]==V[0]）

for（l=1;l<=T[0];l++）//新子串长度与原子串相同时:

直接替换

S[i+l-1]=V[l];

elseif（T[0]

先将后部右移

{

for（l=S[0];l>=i+T[0];l--）

S[l+V[0]-T[0]]=S[l];

for（l=1;l<=V[0];l++）

S[i+l-1]=V[l];

}

else//新子串长度小于原子串时:

先将后部左移

{

for（l=i+V[0];l<=S[0]+V[0]-T[0];l++）

S[l]=S[l-V[0]+T[0]];

for（l=1;l<=V[0];l++）

S[i+l-1]=V[l];

}

S[0]=S[0]-T[0]+V[0];

i+=V[0];n++;

}//if

}//for

returnn;

}//String_Replace

4.18

typedefstruct{

charch;

intnum;

}mytype;

voidStrAnalyze（StringtypeS）//统计串S中字符的种类和个数

{

mytypeT[MAXSIZE];//用结构数组T存储统计结果

for（i=1;i<=S[0];i++）

{

c=S[i];j=0;

while（T[j].ch&&T[j].ch!

=c）j++;//查找当前字符c是否已记录过

if（T[j].ch）T[j].num++;

elseT[j]={c,1};

}//for

for（j=0;T[j].ch;j++）

printf（"%c:

%d\n",T[j].ch,T[j].num）;

}//StrAnalyze

4.19

voidSubtract_String（Stringtypes,Stringtypet,Stringtype&r）//求所有包含在串s中而t中没有的字符构成的新串r

{

r[0]=0;

for（i=1;i<=s[0];i++）

{

c=s[i];

for（j=1;j

=c;j++）;//判断s的当前字符c是否第一次出现

if（i==j）

{

for（k=1;k<=t[0]&&t[k]!

=c;k++）;//判断当前字符是否包含在t中

if（k>t[0]）r[++r[0]]=c;

}

}//for

}//Subtract_String

4.20

intSubString_Delete（Stringtype&s,Stringtypet）//从串s中删除所有与t相同的子串,并返回删除次数

{

for（n=0,i=1;i<=s[0]-t[0]+1;i++）

{

for（j=1;j<=t[0]&&s[i+j-1]==t[i];j++）;

if（j>m）//找到了与t匹配的子串

{

for（k=i;k<=s[0]-t[0];k++）s[k]=s[k+t[0]];//左移删除

s[0]-=t[0];n++;

}

}//for

returnn;

}//Delete_SubString

4.21

typedefstruct{

charch;

LStrNode*next;

}LStrNode,*LString;//链串结构

voidStringAssign（LString&s,LStringt）//把串t赋值给串s

{

s=malloc（sizeof（LStrNode））;

for（q=s,p=t->next;p;p=p->next）

{

r=（LStrNode*）malloc（sizeof（LStrNode））;

r->ch=p->ch;

q->next=r;q=r;

}

q->next=NULL;

}//StringAssign

voidStringCopy（LString&s,LStringt）//把串t复制为串s.与前一个程序的区别在于,串s业已存在.

{

for（p=s->next,q=t->next;p&&q;p=p->next,q=q->next）

{

p->ch=q->ch;pre=p;

}

while（q）

{

p=（LStrNode*）malloc（sizeof（LStrNode））;

p->ch=q->ch;

pre->next=p;pre=p;

}

p->next=NULL;

}//StringCopy

charStringCompare（LStrings,LStringt）//串的比较,s>t时返回正数,s=t时返回0,s

{

for（p=s->next,q=t->next;p&&q&&p->ch==q->ch;p=p->next,q=q->next）;

if（!

p&&!

q）return0;

elseif（!

p）return-（q->ch）;

elseif（!

q）returnp->ch;

elsereturnp->ch-q->ch;

}//StringCompare

intStringLen（LStrings）//求串s的长度（元素个数）

{

for（i=0,p=s->next;p;p=p->next,i++）;

returni;

}//StringLen

LString*Concat（LStrings,LStringt）//连接串s和串t形成新串,并返回指针

{

p=malloc（sizeof（LStrNode））;

for（q=p,r=s->next;r;r=r->next）

{

q->next=（LStrNode*）malloc（sizeof（LStrNode））;

q=q->next;

q->ch=r->ch;

}//for//复制串s

for（r=t->next;r;r=r->next）

{

q->next=（LStrNode*）malloc（sizeof（LStrNode））;

q=q->next;

q->ch=r->ch;

}//for//复制串t

q->next=NULL;

returnp;

}//Concat

LString*Sub_String（LStrings,intstart,intlen）//返回一个串,其值等于串s从start位置起长为len的子串

{

p=malloc（sizeof（LStrNode））;q=p;

for（r=s;start;start--,r=r->next）;//找到start所对应的结点指针r

for（i=1;i<=len;i++,r=r->next）

{

q->next=（LStrNode*）malloc（sizeof（LStrNode））;

q=q->next;

q->ch=r->ch;

}//复制串t

q->next=NULL;

returnp;

}//Sub_String

4.22

voidLString_Concat（LString&t,LString&s,charc）//用块链存储结构,把串s插入到串t的字符c之后

{

p=t.head;

while（p&&!

（i=Find_Char（p,c）））p=p->next;//查找字符c

if（!

p）//没找到

{

t.tail->next=s.head;

t.tail=s.tail;//把s连接在t的后面

}

else

{

q=p->next;

r=（Chunk*）malloc（sizeof（Chunk））;//将包含字符c的节点p分裂为两个

for（j=0;jch[j]='#';//原结点p包含c及其以前的部分

for（j=i;j

{

r->ch[j]=p->ch[j];

p->ch[j]='#';//p的后半部分和r的前半部分的字符改为无效字符'#'

}

p->next=s.head;

s.tail->next=r;

r->next=q;//把串s插入到结点p和r之间

}//else

t.curlen+=s.curlen;//修改串长

s.curlen=0;

}//LString_Concat

intFind_Char（Chunk*p,charc）//在某个块中查找字符c,如找到则返回位置是第几个字符,如没找到则返回0

{

for（i=0;ich[i]!

=c;i++）;

if（i==CHUNKSIZE）return0;

elsereturni+1;

}//Find_Char

4.23

intLString_Palindrome（LStringL）//判断以块链结构存储的串L是否为回文序列,是则返回1,否则返回0

{

InitStack（S）;

p=S.head;i=0;k=1;//i指示元素在块中的下标,k指示元素在整个序列中的序号（从1开始）

for（k=1;k<=S.curlen;k++）

{

if（k<=S.curlen/2）Push（S,p->ch[i]）;//将前半段的字符入串

elseif（k>（S.curlen+1）/2）

{

Pop（S,c）;//将后半段的字符与栈中的元素相匹配

if（p->ch[i]!

=c）return0;//失配

}

if（++i==CHUNKSIZE）//转到下一个元素,当为块中最后一个元素时,转到下一块

{

p=p->next;

i=0;

}

}//for

return1;//成功匹配

}//LString_Palindrome

4.24

voidHString_Concat（HStrings1,HStrings2,HString&t）//将堆结构表示的串s1和s2连接为新串t

{

if（t.ch）free（t.ch）;

t.ch=malloc（（s1.length+s2.length）*sizeof（char））;

for（i=1;i<=s1.length;i++）t.ch[i-1]=s1.ch[i-1];

for（j=1;j<=s2.length;j++,i++）t.ch[i-1]=s2.ch[j-1];

t.length=s1.length+s2.length;

}//HString_Concat

4.25

intHString_Replace（HString&S,HStringT,HStringV）//堆结构串上的置换操作,返回置换次数

{

for（n=0,i=0;i<=S.length-T.length;i++）

{

for（j=i,k=0;k

if（k==T.length）//找到了与T匹配的子串:

分三种情况处理

{

if（T.length==V.length）

for（l=1;l<=T.length;l++）//新子串长度与原子串相同时:

直接替换

S.ch[i+l-1]=V.ch[l-1];

elseif（T.length

先将后部右移

{

for（l=S.length-1;l>=i+T.length;l--）

S.ch[l+V.length-T.length]=S.ch[l];

for（l=0;l

S[i+l]=V[l];

}

else//新子串长度小于原子串时:

先将后部左移

{

for（l=i+V.length;l

S.ch[l]=S.ch[l-V.length+T.length];

for（l=0;l

S[i+l]=V[l];

}

S.length+=V.length-T.length;

i+=V.length;n++;

}//if

}//for

returnn;

}//HString_Replace

4.26

StatusHString_Insert（HString&S,intpos,HStringT）//把T插入堆结构表示的串S的第pos个字符之前

{

if（pos<1）returnERROR;

if（pos>S.length）pos=S.length+1;//当插入位置大于串长时,看作添加在串尾

S.ch=realloc（S.ch,（S.length+T.length）*sizeof（char））;

for（i=S.length-1;i>=pos-1;i--）

S.ch[i+T.length]=S.ch[i];//后移为插入字符串让出位置

for（i=0;i

S.ch[pos+i-1]=T.ch[pos];//插入串T

S.length+=T.length;

returnOK;

}//HString_Insert

4.27

intIndex_New（Stringtypes,Stringtypet）//改进的定位算法

{

i=1;j=1;

while（i<=s[0]&&j<=t[0]）

{

if（（j!

=1&&s[i]==t[j]）||（j==1&&s[i]==t[j]&&s[i+t[0]-1]==t[t[0]]））

{//当j==1即匹配模式串的第一个字符时,需同时匹配其最后一个

i=i+j-2;

j=1;

}

else

{

i++;j++;

}

}//while

if（j>t[0]）returni-t[0];

}//Index_New

4.28

voidLGet_next（LString&T）//链串上的get_next算法

{

p=T->succ;p->next=T;q=T;

while（p->succ）

{

if（q==T||p->data==q->data）

{

p=p->succ;q=q->succ;

p->next=q;

}

elseq=q->next;

}//while

}//LGet_next

4.29

LStrNode*LIndex_KMP（LStringS,LStringT,LStrNode*pos）//链串上的KMP匹配算法,返回值为匹配的子串首指针

{

p=pos;q=T->succ;

while（p&&q）

{

if（q==T||p->chdata==q->chdata）

{

p=p->succ;

q=q->succ;

}

elseq=q->next;

}//while

if（!

q）

{

for（i=1;i<=Strlen（T）;i++）

p=p->next;

returnp;

}//发现匹配后,要往回找子串的头

returnNULL;

}//LIndex_KMP

4.30

voidGet_LRepSub（StringtypeS）//求S的最长重复子串的位置和长度

{

for（maxlen=0,i=1;i

{

for（k=0,j=1;j<=S[0]-i;j++）//j为串S2的当前指针,此时串S1的当前指针为i+j,两指针同步移动

{

if（S[j]==S[j+i]）k++;//用k记录连续相同的字符数

elsek=0;//失配时k归零

if（k>maxlen）//发现了比以前发现的更长的重复子串

{

lrs1=j-k+1;lrs2=mrs1+i;maxlen=k;//作记录

}

}//for

}//for

if（maxlen）

{

printf（"LongestRepeatingSubstringlength:

%d\n",maxlen）;

printf（"Position1:

%dPositio