程序员部分寒假习题答案Word文档格式.docx
《程序员部分寒假习题答案Word文档格式.docx》由会员分享，可在线阅读，更多相关《程序员部分寒假习题答案Word文档格式.docx（22页珍藏版）》请在冰豆网上搜索。
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））;
10）编写“由一个算数表达式的前缀式求后缀式”的递推算法
StatusNibolan_to_bolan（Stringtypestr,Stringtype&
new）
Initstack（s）;
for（i=1;
=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））;
push（s,c）;
}
pop（s,new）;
StackEmpty（s））returnERROR;
returnOK;
11）实现串的基本操作StrAssign（&
T,chars）.
voidStrAssign（StringType&
T,charchars&
#;
）
for（i=0,T[0]=0;
chars[i];
T[0]++,i++）T[i+1]=chars[i];
12）实现串的基本操作StrCompare（S,T）
charstrcompare（StringTypes,StringTypet）
=s[0]&
&
=t[0]&
s[i]==t[i];
if（i>
s[0]&
i>
t[0]）return0;
elseif（i>
s[0]）return–t[i];
t[0]）returns[i];
elsereturns[i]-t[i];
13）实现串的基本操作Replace（&
S,T,V）.
boolrepl（SString&
NewS，SStrings，SStringT，SStringV）
m=S[0];
n=T[0];
overflow=FALSE;
i=k=l;
l=0;
while（!
overflow&
m-k+1>
=n）
j=1;
while（j<
=n&
S[k+j-1]==T[j]）j++;
if（j<
=n）k++;
else
if（l+k-i+V[0]>
MAXSTRLEN）overflow=TURE;
else{
copy（NewS，S，l+1，i，k-i）；
copy（NewS，V，l+k-i，l，V[0]）;
i=k+n;
k=I;
l=l+k-i+V[0];
if（!
=m&
+（m-i+1）<
=MAXSTRLEN）
copy（NewS，S，l+1，i，m-i+1）;
elseoverflow=TURE;
return（!
overflow）;
14）求串S所含不同字符的总数和每种字符的个数。
typedefstruct{
charch;
intnum;
}mytype;
voidStrAnalyze（StringtypeS）
mytypeT[MAXSIZE];
=S[0];
c=S[i];
j=0;
while（T[j].ch&
T[j].ch!
=c）j++;
if（T[j].ch）T[j].num++;
elseT[j]={c，l};
for（j=0;
T[j].ch;
j++）
printf（“%c;
%d\n”,T[j].ch,T[j].num）;
15）假设以结点大小为1（且附设头结点）的链表结构表示串。
试编写实现下列六种串的基本操作StrAssign，StrCompare，StrLength，Concat和SubString的函数。
typedefstruct{
LStrNode*next;
}LStrNode，*LString;
voidStringAssign（LString&
s，LStringt）
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;
next=NULL;
voidStringCopy（LString&
s，LString）
for（p=s->
next,q=t->
p&
q;
next,q=q->
p->
ch=q->
pre=p;
while（q）
{‘
p=（LStrNode*）malloc（sizeof（LStrNode））;
pre->
next=p;
charStringCompare（LStrings,LStringt）
q&
p->
ch==q->
next）;
!
q）return0;
elseif（!
p）return–（q->
ch）;
q）returnp->
elsereturnp->
ch-q->
intStringLen（LStrings）
for（i=0,p=s->
next,i++）;
returnI;
LString*Concat（LStrings,LStringt）
p=malloc（sizeof（LStrNode））;
for（q=p,r=s->
r;
r=r->
next）
next=（LStrNode*）malloc（sizeof（LStrNode））;
q=q->
ch=r->
for（r=t->
r->
returnp;
LString*Sub_String（LStrings,intstart,intlen）
q=p;
for（r=s;
start;
start--,r=r->
=len;
i++,r=r->
next（LStrNode*）malloc（sizeof（LStrNode））;
16）假设以块链结构表示串。
试编写将串s插入到串t中某个字符之后的算法（若串t中不存在此字符，则将串s联接在串t的末尾）。
voidLString_Concat（LString&
t,LString&
s,charc）
p=t.head;
while（p&
（i=Find_Char（p,c）））p=p->
p）
t.tail->
next=s.head;
t.tail=s.tail;
q=p->
r=（Chunk*）malloc（sizeof（chunk））;
j<
i;
j++）r->
ch[j]=’#’;
for（j=i;
CHUNKSIZE;
ch[j]=p->
ch[j];
s.tail->
next=q;
t.curlen+=s.curlen;
s.curlen=0;
intFind_Char（Chunk*p,charc）
for（i=0;
CHUNKSIZE&
ch[i]!
=c,i++）\
if（i==CHUNKSIZE）return0;
elsereturni+1;
17）假设以块链结构作串的存储结构。
试编写判别给定串是否具有对称性的算法，并要求算法的时间复杂度为o（StrLength（S））.
intLString_Palindrome（LStrings）
IntStack（stack）;
p=S.head;
i=0;
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->
=c）return0;
if（++i==CHUNKSIZE）
p=p->
i=0;
return1;
18）在串的堆存储结构上实现串的基本操作Concat（&
T，s1，s2）。
voidHString_Concat（HStrings1,HStrings2,HString&
t）
升级会员 