最全数据结构课后习题答案耿国华版文档格式.docx

最全数据结构课后习题答案耿国华版文档格式.docx

《最全数据结构课后习题答案耿国华版文档格式.docx》由会员分享，可在线阅读，更多相关《最全数据结构课后习题答案耿国华版文档格式.docx（23页珍藏版）》请在冰豆网上搜索。

{p=p+a[i]*x;

n次*/

x=x*x;

}

printf（“%f”,p）;

}

算法的时间复杂度：

T（n）=O（n）

通过参数表中的参数显式传递

floatPolyValue（floata[],floatx,intn）

{

floatp,s;

inti;

p=x;

s=a[0];

for（i=1;

{s=s+a[i]*p;

/*执行次数:

n次*/

p=p*x;

return（p）;

第2章线性表

习题

1.填空：

（1）在顺序表中插入或删除一个元素，需要平均移动一半元素，具体移动的元素个数与插入或删除的位置有关。

（2）线性表有顺序和链式两种存储结构。

在顺序表中，线性表的长度在数组定义时就已经确定，是静态保存，在链式表中，整个链表由“头指针”来表示，单链表的长度是动态保存。

（3）在顺序表中，逻辑上相邻的元素，其物理位置＿一定＿＿＿＿＿相邻。

在单链表中，逻辑上相邻的元素，其物理位置不一定相邻。

（4）在带头结点的非空单链表中，头结点的存储位置由头指针指示，首元素结点的存储位置由头结点指示，除首元素结点外，其它任一元素结点的存储位置由其直接前趋的next域指示。

2.选择题

（1）A

（2）已知L是无表头结点的单链表，且P结点既不是首元素结点，也不是尾元素结点。

按要求从下列语句中选择合适的语句序列。

a.在P结点后插入S结点的语句序列是：

E、A。

b.在P结点前插入S结点的语句序列是：

H、L、I、E、A。

c.在表首插入S结点的语句序列是：

F、M。

d.在表尾插入S结点的语句序列是：

L、J、A、G。

供选择的语句有：

AP->

next=S;

BP->

next=P->

next->

next;

CP->

next=S->

DS->

ES->

next=L;

FS->

next=NULL;

GQ=P;

Hwhile（P->

next!

=Q）P=P->

Iwhile（P->

=NULL）P=P->

JP=Q;

KP=L;

LL=S;

ML=P;

（3）D

（4）D

（5）D

（6）A

7试分别以不同的存储结构实现单线表的就地逆置算法，即在原表的存储空间将线性表（a1,a2,…,an）逆置为（an,an-1,…,a1）。

（1）用一维数组作为存储结构

void 

invert（SeqList 

*L, 

int 

*num）

{ 

j;

ElemType 

tmp;

for（j=0;

=（*num-1）/2;

{tmp=L[j];

L[j]=L[*num-j-1];

L[*num-j-1]=tmp;

（2）用单链表作为存储结构

invert（LinkList 

L）

Node 

*p,*q,*r;

if（L->

next==NULL） 

return;

/*链表为空*/

p=L->

q=p->

p->

next=NULL;

/*摘下第一个结点，生成初始逆置表*/

while（q!

=NULL） 

/*从第二个结点起依次头插入当前逆置表*/

r=q->

q->

next=L->

L->

next=q;

q=r;

11将线性表A=（a1,a2,……am）,B=（b1,b2,……bn）合并成线性表C,C=（a1,b1,……am,bm,bm+1,…….bn） 

当m<

=n时，或C=（a1,b1,……an,bn,an+1,……am）当m>

n时,线性表A、B、C以单链表作为存储结构，且C表利用A表和B表中的结点空间构成。

单链表的长度值m和n均未显式存储。

【解答】算法如下：

LinkList 

merge（LinkList 

A, 

LinkListB, 

LinkList 

C）

{Node 

*pa,*qa,*pb,*qb,*p;

pa=A->

/*pa表示A的当前结点*/

pb=B->

p=A;

/*利用p来指向新连接的表的表尾，初始值指向表A的头结点*/

while（pa!

=NULL 

&

&

pb!

/*利用尾插法建立连接之后的链表*/

qa=pa->

qb=qb->

p->

next=pa;

/*交替选择表A和表B中的结点连接到新链表中；

*/

p=pa;

next=pb;

p=pb;

pa=qa;

pb=qb;

if（pa!

/*A的长度大于B的长度*/

if（pb!

/*B的长度大于A的长度*/

C=A;

Return（C）;

实习题 

约瑟夫环问题

约瑟夫问题的一种描述为：

编号1,2,…,n的n个人按顺时针方向围坐一圈，每个人持有一个密码（正整数）。

一开始任选一个报数上限值m,从第一个人开始顺时针自1开始顺序报数，报到m时停止报数。

报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有的人全部出列为止。

试设计一个程序，求出出列顺序。

利用单向循环链表作为存储结构模拟此过程，按照出列顺序打印出各人的编号。

例如m的初值为20；

n=7，7个人的密码依次是：

3,1,7,2,4,8,4,出列顺序为6,1,4,7,2,3,5。

typedefstructNode

{

intpassword;

intnum;

structNode*next;

} 

Node,*Linklist;

voidJosephus（）

LinklistL;

Node*p,*r,*q;

intm,n,C,j;

L=（Node*）malloc（sizeof（Node））;

/*初始化单向循环链表*/

if（L==NULL）{printf（"

\n链表申请不到空间!

"

）;

return;

L->

r=L;

printf（"

请输入数据n的值（n>

0）:

scanf（"

%d"

&

for（j=1;

j++） 

/*建立链表*/

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

if（p!

=NULL）

请输入第%d个人的密码:

j）;

C）;

password=C;

num=j;

r->

next=p;

r=p;

printf（"

请输入第一个报数上限值m（m>

m）;

*****************************************\n"

出列的顺序为:

\n"

q=L;

while（n!

=1） 

/*计算出列的顺序*/

j=1;

while（j<

m） 

/*计算当前出列的人选p*/

q=p;

/*q为当前结点p的前驱结点*/

p=p->

j++;

%d->

p->

num）;

m=p->

password;

/*获得新密码*/

n--;

q->

next=p->

/*p出列*/

free（r）;

%d\n"

第3章限定性线性表—栈和队列

第三章答案

1按3.1（b）所示铁道（两侧铁道均为单向行驶道）进行车厢调度，回答：

（1）如进站的车厢序列为123，则可能得到的出站车厢序列是什么？

（2）如进站的车厢序列为123456，能否得到435612和135426的出站序列，并说明原因（即写出以“S”表示进栈、“X”表示出栈的栈序列操作）。

（1）可能得到的出站车厢序列是：

123、132、213、231、321。

（2）不能得到435612的出站序列。

因为有S

（1）S

（2）S（3）S（4）X（4）X（3）S（5）X（5）S（6）S（6），此时按照“后进先出”的原则，出栈的顺序必须为X

（2）X

（1）。

能得到135426的出站序列。

因为有S

（1）X

（1）S

（2）S（3）X（3）S（4）S（5）X（5）X（4）X

（2）X

（1）。

3给出栈的两种存储结构形式名称，在这两种栈的存储结构中如何判别栈空与栈满？

（1）顺序栈（top用来存放栈顶元素的下标）

判断栈S空：

如果S->

top==-1表示栈空。

判断栈S满：

top==Stack_Size-1表示栈满。

（2）链栈（top为栈顶指针，指向当前栈顶元素前面的头结点）

判断栈空：

如果top->

next==NULL表示栈空。

判断栈满：

当系统没有可用空间时，申请不到空间存放要进栈的元素，此时栈满。

4照四则运算加、减、乘、除和幂运算的优先惯例，画出对下列表达式求值时操作数栈和运算符栈的变化过程：

A-B*C/D+E↑F

5写一个算法，判断依次读入的一个以@为结束符的字母序列，是否形如‘序列1&

序列2’的字符序列。

序列1和序列2中都不含‘&

’，且序列2是序列1的逆序列。

例如，’a+b&

b+a’是属于该模式的字符序列，而’1+3&

3-1’则不是。

intIsHuiWen（）

Stack*S;

Charch,temp;

InitStack（&

S）;

Printf（“\n请输入字符序列：

”）;

Ch=getchar（）;

While（ch!

=&

）/*序列1入栈*/

{Push（&

S,ch）;

ch=getchar（）;

do/*判断序列2是否是序列1的逆序列*/

{ch=getchar（）;

Pop（&

S,&

temp）;

if（ch!

=temp）/*序列2不是序列1的逆序列*/

{return（FALSE）;

printf（“\nNO”）;

}

}while（ch!

=@&

!

IsEmpty（&

S））

if（ch==@&

IsEmpty（&

{return（TRUE）;

printf（“\nYES”）;

}/*序列2是序列1的逆序列*/

else

{return（FALSE）;

}/*IsHuiWen（）*/

8要求循环队列不损失一个空间全部都能得到利用，设置一个标志tag,以tag为0或1来区分头尾指针相同时的队列状态的空与满，请编写与此相应的入队与出队算法。

【解答】入队算法：

intEnterQueue（SeqQueue*Q,QueueElementTypex）

{/*将元素x入队*/

if（Q->

front==Q->

front&

tag==1）/*队满*/

return（FALSE）;

tag==0）/*x入队前队空，x入队后重新设置标志*/

tag=1;

Q->

elememt[Q->

rear]=x;

rear=（Q->

rear+1）%MAXSIZE;

/*设置队尾指针*/

Return（TRUE）;

出队算法：

intDeleteQueue（SeqQueue*Q,QueueElementType*x）

{/*删除队头元素，用x返回其值*/

if（Q->

rear&

tag==0）/*队空*/

*x=Q->

element[Q->

front];

front=（Q->

front+1）%MAXSIZE;

/*重新设置队头指针*/

rear）tag=0;

/*队头元素出队后队列为空，重新设置标志域*/

Return（TUUE）;

第4章串

第四章答案

1设s=’IAMASTUDENT’，t=’GOOD’，q=’WORKER’。

给出下列操作的结果：

【解答】StrLength（s）=14;

SubString（sub1,s,1,7）sub1=’IAMA’;

SubString（sub2,s,7,1）sub2=’’;

StrIndex（s,4,’A’）=6;

StrReplace（s,’STUDENT’,q）;

s=’IAMAWORKER’;

StrCat（StrCat（sub1,t）,StrCat（sub2,q））sub1=’IAMAGOODWORKER’。

2编写算法，实现串的基本操作StrReplace（S,T,V）。

【解答】算法如下：

intstrReplace（SStringS,SStringT,SStringV）

{/*用串V替换S中的所有子串T*/

intpos,i;

pos=strIndex（S,1,T）;

/*求S中子串T第一次出现的位置*/

if（pos==0）return（0）;

while（pos!

=0）/*用串V替换S中的所有子串T*/

switch（T.len-V.len）

case0:

/*串T的长度等于串V的长度*/

for（i=0;

=V.len;

i++）/*用V替换T*/

S->

ch[pos+i]=V.ch[i];

case>

0:

/*串T的长度大于串V的长度*/

for（i=pos+t.ien;

S->

len;

i--）/*将S中子串T后的所有字符

ch[i-t.len+v.len]=S->

ch[i];

前移T.len-V.len个位置*/

len=S->

len-T.len+V.len;

case<

/*串T的长度小于串V的长度*/

if（S->

len-T.len+V.len）<

=MAXLEN/*插入后串长小于MAXLEN*/

{/*将S中子串T后的所有字符后移V.len-T.len个位置*/

for（i=S->

i>

=pos+T.len;

i--）

ch[i]=S->

ch[i-T.len+V.len];

else

{/*替换后串长>

MAXLEN,但串V可以全部替换*/

if（pos+V.len<

=MAXLEN）

{for（i=MAXLEN-1;

i--）

ch[i]=s->

ch[i-T.len+V.len]

len=MAXLEN;

else/*串V的部分字符要舍弃*/

{for（i=0;

MAXLEN-pos;

ch[i+pos]=V.ch[i];

}/*switch（）*/

pos=StrIndex（S,pos+V.len,T）;

/*求S中下一个子串T的位置*/

}/*while（）*/

return

（1）;

}/*StrReplace（）*/

第五章数组和广义表

第五章答案

1.假设有6行8列的二维数组A，每个元素占用6个字节，存储器按字节编址。

已知A的基地址为1000，计算：

（1）数组A共占用多少字节；

（288）

（2）数组A的最后一个元素的地址；

（1282）

（3）按行存储时，元素A36的地址；

（1126）

（4）按列存储时，元素A36的地址；

（1192）

4.设有三对角矩阵An×

n,将其三条对角线上的元素逐行的存于数组B[1..3n-2]中，使得B[k]=aij，求：

（1）用i,j表示k的下标变换公式；

（2）用k表示i、j的下标变换公式。

（1）k=2（i-1）+j

（2）i=[k/3]+1,j=[k/3]+k%3（[]取整，%取余）

5.在稀疏矩阵的快速转置算法5.2中，将计算position[col]的方法稍加改动，使算法只占用一个辅助向量空间。

【解答】算法

（一）

FastTransposeTSMatrix（TSMartrixA,TSMatrix*B）

{/*把矩阵A转置到B所指向的矩阵中去，矩阵用三元组表表示*/

intcol,t,p,q;

intposition[MAXSIZE];

B->

len=A.len;

B->

n=A.m;

m=A.n;

if（B->

len>

0）

position[1]=1;

for（t=1;

t<

=A.len;

t++）

position[A.data[t].col+1]++;

/*position[col]存放第col-1列非零元素的个数,即利用pos[col]来记录第col-1列中非零元素的个数*/

/*求col列中第一个非零元素在B.data[]的位置，存放在position[col]中*/

for（col=2;

col<

=A.n;

col++）

position[col]=position[col]+position[col-1];

for（p=1;

p<

A.len;

p++）

col=A.data[p].col;

q=position[col];

data[q].row=A.data[p].col;

data[q].col=A.data[p].row;

data[q].e=A.data[p].e;

Position[col]++;

算法

（二）

FastTransposeTSMatrix（TSMartrixA,TSMatrix*B）

for（col=1;

col++）

position[col]=0;

position[A.data[t].col]++;

/*计算每一列的非零元素的个数*/

/*从最后一列起求每一列中第一个非零元素在B.data[]中的位置，存放在position[col]中*/

for（col=A.n,t=A.len;

col>

0;

col--）

{t=t-position[col];

position[col]=t+1;

8.画出下面广义表的两种存储结构图示：

（（（（a）,b））,（（（）,d）,（e,f）））

第一种存储结构

第二种存储结构

9.求下列广义表运算的结果：

（1）HEAD[（（a,b）,（c,d））];

（a,b）