数据结构C语言的描述课后大部分习题答案Word文件下载.docx

数据结构C语言的描述课后大部分习题答案Word文件下载.docx

《数据结构C语言的描述课后大部分习题答案Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构C语言的描述课后大部分习题答案Word文件下载.docx（41页珍藏版）》请在冰豆网上搜索。

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

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

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

算法如下：

通过全局变量隐式传递参数

PolyValue（）

{inti,n;

floatx,a[],p;

printf（“\nn=”）;

scanf（“%f”,&

n）;

printf（“\nx=”）;

x）;

for（i=0;

n;

scanf（“%f”,&

a[i]）;

/*执行次数：

n次*/

p=a[0];

{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];

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

/*执行次数:

p=p*x;

return（p）;

第二章答案

约瑟夫环问题

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

编号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"

&

j++）/*建立链表*/

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

if（p!

=NULL）

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

j）;

C）;

p->

password=C;

num=j;

r->

next=p;

r=p;

next=L->

next;

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

m）;

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

出列的顺序为:

\n"

q=L;

p=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"

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

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

voidinvert（SeqList*L,int*num）

intj;

ElemTypetmp;

for（j=0;

=（*num-1）/2;

{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;

/*链表为空*/

q=p->

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

while（q!

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

r=q->

next=q;

q=r;

2.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->

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

pb=B->

p=A;

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

while（pa!

=NULL&

&

pb!

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

{qa=pa->

qb=qb->

next=pa;

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

*/

p=pa;

next=pb;

p=pb;

pa=qa;

pb=qb;

if（pa!

=NULL）p->

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

if（pb!

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

C=A;

Return（C）;

第三章答案

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.3给出栈的两种存储结构形式名称，在这两种栈的存储结构中如何判别栈空与栈满？

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

判断栈S空：

如果S->

top==-1表示栈空。

判断栈S满：

top==Stack_Size-1表示栈满。

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

判断栈空：

如果top->

next==NULL表示栈空。

判断栈满：

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

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

A-B*C/D+E↑F

3．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（）*/

3.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）

{/*删除队头元