完整版数据结构c语言描述第二版答案耿国华西安电子科技大学.docx

完整版数据结构c语言描述第二版答案耿国华西安电子科技大学.docx

《完整版数据结构c语言描述第二版答案耿国华西安电子科技大学.docx》由会员分享，可在线阅读，更多相关《完整版数据结构c语言描述第二版答案耿国华西安电子科技大学.docx（26页珍藏版）》请在冰豆网上搜索。

完整版数据结构c语言描述第二版答案耿国华西安电子科技大学

第1章绪论

2.

（1）X

（2）X（3）V

3.

（1）A⑵C（3）C

5.计算以下程序中x=x+1的语句频度for（i=1;i<=n;i++）

for（j=1;j<=i;j++）for（k=1;k<=j;k++）x=x+1;

【解答】x=x+1的语句频度为：

T（n）=1+（1+2）+（1+2+3）+……+（1+2+……+n）=n（n+1）（n+2）/6

6.编写算法,求一元多项式pn（x）=a0+a[x+a2x2+.+anxn的值Pn（x0）,并确定算法中每一语句的执行次数和整个算法的时间复杂度,要求时间复杂度尽可能小,规定算法中不能使用求

哥函数.注意：

此题中的输入为ai（i=0,1,…n"和"输出为Pn（x0）.算法的输入和输出采用以下方法

（1）通过参数表中的参数显式传递

（2）通过全局变量隐式传递.讨论两种方法的优缺点,并在算法中以你认为较好的一种实现输入输出.

【解答】

（1）通过参数表中的参数显式传递

优点：

当没有调用函数时,不占用内存,调用结束后形参被释放,实参维持,函数通用性强,移置性强.

缺点：

形参须与实参对应,且返回值数量有限.

（2）通过全局变量隐式传递

优点：

减少实参与形参的个数,从而减少内存空间以及传递数据时的时间消耗

缺点：

函数通用性降低,移植性差

算法如下：

通过全局变量隐式传递参数PolyValue（）{inti,n;

floatx,a[],p;

printf（nn="）;

scanf（"%f",&n）;

printf（nx="）;

scanf（"%f",&x）;for（i=0;i

n次*/p=a[0];

for（i=1;i<=n;i++）

{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;i<=n;i++）

/*执行次数：

n次*/

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

p=p*x;}return（p）;

}

算法的时间复杂度：

T（n）=O（n）

第2章线性表

习题

2.选择题

ML=P;

⑶D

（4）D

⑸D

（6）A

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

【解答】

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

voidinvert（SeqList*L,int*num）

（

intj;

ElemTypetmp;

for（j=0;j<=（*num-1）/2;j++）

{tmp=L[j];

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

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

}

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

voidinvert（LinkListL）

{

Node*p,*q,*r;

if（L->next==NULL）return;/*链表为空*/

p=L->next;

q=p->next;

p->next=NULL;/*摘下第一个结点,生成初始逆置表*/

while（q!

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

{

r=q->next;

q->next=L->next;

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均未显式存储.【解答】算法如下：

LinkListmerge（LinkListA,LinkListB,LinkListC）{Node*pa,*qa,*pb,*qb,*p;pa=A->next;/*pa表示A的当前结点*/

pb=B->next;p=A;/*利用p来指向新连接的表的表尾,初始值指向表A的头结点*/

while（pa!

=NULL

{qa=pa->next;

qb=qb->next;

p->next=pa;

p=pa;

p->next=pb;

p=pb;

&&pb!

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

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

pa=qa;

pb=qb;

实习题

约瑟夫环问题

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

编号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->next=NULL;

r=L;

printf（"请输入数据n的值（n>0）:

"）;

scanf（"%d",&n）;

for（j=1;j<=n;j++）/*建立链表*/

{

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

=NULL）

{

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

",j）;

scanf（"%d",&C）;

p->password=C;

p->num=j;r->next=p;r=p;

}}r->next=L->next;

printf（"请输入第一个报数上限值m（m>0）:

"）;

scanf（"%d",&m）;

printf（"*****************************************\n"）;

printf（"出列的顺序为:

\n"）;

q=L;

p=L->next;

while（n!

=1）/*计算出列的顺序*/

{

j=1;

while（j

{

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

p=p->next;

j++;

}

printf（"%d->",p->num）;

m=p->password;/*获得新密码*/

/*p出列*/

n--;

q->next=p->next;

r=p;

p=p->next;

free（r）;

}

printf（"%d\n",p->num）;

}

第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满：

如果S->top==Stack_Size-1表示栈满.

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

判断栈空：

如果top->next==NULL表示栈空.

判断栈满：

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

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

A-B*C/D+ETF

8要求循环队列不损失一个空间全部都能得到利用,设置一个标志tag,以tag为0或1来

区分头尾指针相同时的队列状态的空与满,请编写与此相应的入队与出队算法.

【解答】入队算法：

intEnterQueue（SeqQueue*Q,QueueElementTypex）

{/*将元素x入队*/

if（Q->front==Q->front&&tag==1）

return（FALSE）;

if（Q->front==Q->front&&tag==0）

tag=1;

Q->elememt[Q->rear]=x;

Q->rear=（Q->rear+1）%MAXSIZE;Return（TRUE）;

}

出队算法：

intDeleteQueue（SeqQueue*Q,{/*删除队头元素,用x返回其值*/

if（Q->front==Q->rear&&tag==0）return（FALSE）;

*x=Q->element[Q->front];

Q->front=（Q->front+1）%MAXSIZE;

if（Q->front==Q->rear）tag=0;

Return（TUUE）;

}

/*队满*/

/*x入队前队空,x入队后重新设置标志*/

/*设置队尾指针*/

QueueElementType*x）

/*队空*/

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

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

第四章答案

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:

for（i=0;i<=V.len;i++）

S->ch[pos+i]=V.ch[i];

case>0:

for（i=pos+t.ien;ilen;i--）

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

for（i=0;i<=V.len;i++）

S->ch[pos+i]=V.ch[i];

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

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

S->len=S->len-T.len+V.len;

case<0:

if（S->len-T.len+V.len）<=MAXLEN

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

for（i=S->len-T.len+V.len;i>=pos+T.len;i--）

S->ch[i]=S->ch[i-T.len+V.len];

for（i=0;i<=V.len;i++）/*用V替换T*/

S->ch[pos+i]=V.ch[i];

S->len=S->len-T.len+V.len;}

else

{/*替换后串长>MAXLEN,但串V可以全部替换*/

if（pos+V.len<=MAXLEN）

{for（i=MAXLEN-1;i>=pos+T.len;i--）

S->ch[i]=s->ch[i-T.len+V.len]

/*用V替换T*/

/*串V的局部字符要舍弃*/

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

for（i=0;i<=V.len;i++）

S->ch[pos+i]=V.ch[i];

S->len=MAXLEN;}else

{for（i=0;i

S->ch[i+pos]=V.ch[i];

S->len=MAXLEN;}}/*switch（）*/

pos=StrIndex（S,pos+V.len,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.,将其三条对角线上的元素逐行的存于数组B[1..3n-2]中,使得

B[k]=a方求：

〔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;B->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

col=A.data[p].col;

q=position[col];

B->data[q].row=A.data[p].col;

B->data[q].col=A.data[p].row;

B->data[q].e=A.data[p].e;

Position[col]++;

}

}

}

算法

（二）

FastTransposeTSMatrix（TSMartrixA,TSMatrix*B）

{

intcol,t,p,q;

intposition[MAXSIZE];

B->len=A.len;B->n=A.m;B->m=A.n;

if（B->len>0）{

for（col=1;col<=A.n;col++）

position[col]=0;

for（t=1;t<=A.len;t++）

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;

}

for（p=1;p

col=A.data[p].col;

q=position[col];

B->data[q].row=A.data[p].col;

B->data[q].col=A.data[p].row;

B->data[q].e=A.data[p].e;

Position[col]++;

}

}

}

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

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

【解答】

第一种存储结构

第二种存储结构

9.求以下广义表运算的结果:

（1）

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

（a,b）

（2）

TAIL[（（a,b）,（c,d））];

（（c,d））

（3）

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

（b）

（4）

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

b

（5）

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

（d）

第六章

第六章答案

6.1分别画出具有3个结点的树和3个结点的二叉树的所有不同形态.【解答】

具有3个结点的树

6.3一棵度为k的树中有ni个度为1的结点,久个度为2的结点,,g个度为k

的结点,那么该树中有多少个叶子结点

【解答】设树中结点总数为"那么n=no+ni+……+❶

树中分支数目为B,贝UB=ni+2n2+3n3++knk

由于除根结点外,每个结点均对应一个进入它的分支,所以有n=B+1

即no+n1++nk=n1+2n2+3n3++knk+1

由上式可得叶子结点数为：

no=n2+2n3+……+（k-1）nk+1

6.5二叉树有50个叶子结点,那么该二叉树的总结点数至少应有多少个

【解答】no表示叶子结点数,n2表示度为2的结点数,那么no=n2+1

所以n2=no-1=49,当二叉树中没有度为1的结点时,总结点数n=no+n2=99

6.6试分别找出满足以下条件的所有二叉树：

（1）前序序列与中序序列相同；

（2）中序序列与后序序列相同；

（3）前序序列与后序序列相同.

【解答】

（1）前序与中序相同：

空树或缺左子树的单支树；

（2）中序与后序相同：

空树或缺右子树的单支树；

（3）前序与后序相同：

空树或只有根结点的二叉树.

6.9假设通讯的电文仅由8个字母组成,字母在电文中出现的频率分别为:

o.o7,o.19,o.o2,o.o6,o.32,o.o3,o.21,o.1o

请为这8个字母设计哈夫曼编码.

【解答】

构造哈夫曼树如下：

1.0

哈夫曼编码为:

1:

11111

I5：

1100

2：

11110

I6：

10

3：

1110I

7：

01

4：

1101I

8：

00

6.16分别写出算法,实现在中序线索二叉树继.在先序线索二叉树T中,查找给定结点中,查找给定结点*p在后序序列中的前驱.

T中查找给定结点*p在中序序列中的前驱与后

*p在先序序列中的后继.在后序线索二叉树T

（1）找结点的中序前驱结点

BiTNode*InPre（BiTNode*p）

/*在中序线索二叉树中查找p的中序前驱结点,并用pre指针返回结果*/

{if（p->Ltag==1）pre=p->LChild;/*直接利用线索*/

else

{/*在p的左子树中查找“最右下端〞结点*/

for（q=p->LChild;q->Rtag==0;q=q->RChild）;pre=q;

}return（pre）;

}

（2）找结点的中序后继结点

BiTNode*InSucc（BiTNode*p）

/*直接利用线索*/

*/

/*在中序线索二叉树中查找p的中序后继结点,并用succ指针返回结果*/

{if（p->Rtag==1）succ=p->RChild;

else

{/*在p的右子树中查找“最左下端〞结点

for（q=p->RChild;q->Ltag==0;q=q->LChild）;

succ=q;

）

return（succ）;

）

（3）找结点的先序后继结点

BiTNode*PreSucc（BiTNode*p）

/*在先序线索二叉树中查找p的先序后继结点,并用succ指针返回结果*/

{if（p->Ltag==0）succ=p->LChild;

elsesucc=p->RChild;

return（succ）;

）

（4）找结点的后序前驱结点

BiTNode*SuccPre（BiTNode*p）

/*在后序线索二叉树中查找p的后序前驱结点,并用pre指针返回结果*/

{if（p->Ltag==1）pre=p->LChild;

elsepre=p->RChild;

return（pre）;

）

6.20二叉树根据二叉链表方式存储,利用栈的根本操作写出先序遍历非递归形式的算法.

【解答】

VoidPreOrder（BiTreeroot）/*先序遍历二叉树的非递归算法*/

{

InitStack（&S）;

p=root;

while（p!

=NULL||!

IsEmpty（S））

{if（p!

=NULL）

{

Visit（p->data）;

push（&S,p）;

p=p->Lchild;

）

else

{

Pop（&S,&p）;

p=p->RChild;

）

）

）

6.26二叉树根据二叉链表方式存储,编写算法将二叉树左右子树进行交换.

【解答】

算法

（一）

Voidexchange（BiTreeroot）

{

p=root;

if（p->LChild!

=NULL||p->RChild!

=NULL）

{

temp=p->LChild;

p->LChild=p->RChild;

p->RChild=temp;

exchange（p->LChild）;

exchange（p->RChild）;））

算法

（二）

Voidexchange（BiTreeroot）（

p=root;

if（p->LChild