严蔚敏 数据结构课后习题及答案解析Word格式.docx
《严蔚敏 数据结构课后习题及答案解析Word格式.docx》由会员分享，可在线阅读，更多相关《严蔚敏 数据结构课后习题及答案解析Word格式.docx（54页珍藏版）》请在冰豆网上搜索。
1.C2.C3.C4.A、B5.C6.C、B
二、判断题:
1、√2、×
3、×
4、×
5、√
三、填空题
1、线性、树形、图形、集合?
；
非线性（网状）2、没有；
1；
没有；
13、前驱；
后继；
任意多个4、任意多个5、一对一；
一对多；
多对多6、有穷性；
确定性；
可行性；
输入；
输出7、数据元素；
逻辑结构；
存储结构8、插入、删除、合并等操作较方便9、顺序存储；
链式存储
四、算法分析题
for（i=1;
i<
=n;
i++）
for（j=1;
j<
=i;
j++）
x=x+1;
分析：
该算法为一个二重循环，执行次数为内、外循环次数相乘，但内循环次数不固定，与外循环有关，因些，时间频度T（n）=1+2+3+…+n=n*（n+1）/2
有1/4≤T（n）/n2≤1，故它的时间复杂度为Ｏ（n2）,即Ｔ（n）与n2数量级相同。
2、分析下列算法段的时间频度及时间复杂度
for（i=1;
i<
i++）
for（j=1;
j<
=i;
j++）
for（k=1;
k<
=j;
k++）
x=i+j-k;
分析算法规律可知时间频度T（n）=1+（1+2）+（1+2+3）+...+（1+2+3+…+n）
由于有1/6≤T（n）/n3≤1，故时间复杂度为Ｏ（n3）
第二章线性表
1.一个线性表第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是（）
（A）110（B）108（C）100（D）120
2.向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动（）个元素。
（A）64（B）63（C）63.5 （D）7
3.线性表采用链式存储结构时，其地址（）。
（A）必须是连续的（B）部分地址必须是连续的
（C）一定是不连续的（D）连续与否均可以
4.在一个单链表中，若p所指结点不是最后结点，在p之后插入s所指结点，则执行（）
（A）s->
next=p;
p->
next=s;
（B）s->
next=p->
next;
（C）s->
p=s;
（D）p->
s->
5.在一个单链表中，若删除p所指结点的后续结点，则执行（）
（A）p->
next->
（B）p=p->
p->
（C）p->
（D）p=p->
6.下列有关线性表的叙述中，正确的是（）
（A）线性表中的元素之间隔是线性关系
（B）线性表中至少有一个元素
（C）线性表中任何一个元素有且仅有一个直接前趋
（D）线性表中任何一个元素有且仅有一个直接后继
7.线性表是具有n个（）的有限序列（n≠0）
（A）表元素（B）字符（C）数据元素 （D）数据项
1.线性表的链接存储，表中元素的逻辑顺序与物理顺序一定相同。
2.如果没有提供指针类型的语言，就无法构造链式结构。
3.线性结构的特点是只有一个结点没有前驱，只有一个结点没有后继，其余的结点只有一个前驱和后继。
4.语句p=p->
next完成了指针赋值并使p指针得到了p指针所指后继结点的数据域值。
5.要想删除p指针的后继结点，我们应该执行q=p->
next；
next=q->
next；
free（q）。
1.已知P为单链表中的非首尾结点，在P结点后插入S结点的语句为：
_______________________。
2.顺序表中逻辑上相邻的元素物理位置（）相邻，单链表中逻辑上相邻的元素物理位置_________相邻。
3.线性表L＝（a1，a2，...，an）采用顺序存储，假定在不同的n＋1个位置上插入的概率相同，则插入一个新元素平均需要移动的元素个数是________________________
4.在非空双向循环链表中，在结点q的前面插入结点p的过程如下：
prior=q->
prior;
q->
prior->
next=q;
______________________;
5.已知L是无表头结点的单链表，是从下列提供的答案中选择合适的语句序列，分别实现：
（1）表尾插入s结点的语句序列是_______________________________
（2）表尾插入s结点的语句序列是_______________________________
1.p->
2.p=L;
3.L=s;
4.p->
next=s->
5.s->
6.s->
next=L;
7.s->
next=null;
8.while（p->
next!
=Q）?
p=p-next;
9.while（p->
=null）p=p->
四、算法设计题
1.试编写一个求已知单链表的数据域的平均值的函数（数据域数据类型为整型）。
2.已知带有头结点的循环链表中头指针为head,试写出删除并释放数据域值为x的所有结点的c函数。
3.某百货公司仓库中有一批电视机，按其价格从低到高的次序构成一个循环链表，每个结点有价格、数量和链指针三个域。
现出库（销售）m台价格为h的电视机，试编写算法修改原链表。
4.某百货公司仓库中有一批电视机，按其价格从低到高的次序构成一个循环链表，每个结点有价格、数量和链指针三个域。
现新到m台价格为h的电视机，试编写算法修改原链表。
5.线性表中的元素值按递增有序排列，针对顺序表和循环链表两种不同的存储方式，分别编写C函数删除线性表中值介于a与b（a≤b）之间的元素。
6.设A=（a0,a1,a2,...,an-1）,B=（b0,b1,b2,...,bm-1）是两个给定的线性表,它们的结点个数分别是n和m,且结点值均是整数。
若n=m，且ai=bi（0≤i<
n），则A=B；
若n<
m，且ai=bi（0≤i<
n），则A<
B；
若存在一个j，j<
m，j<
n，且ai=bi（0≤i<
j），若aj<
bj，则A<
B，否则A>
B。
试编写一个比较A和B的C函数，该函数返回-1或0或1，分别表示A<
B或A=B或A>
7.试编写算法,删除双向循环链表中第k个结点。
8.线性表由前后两部分性质不同的元素组成（a0,a1,...,an-1,b0,b1,...,bm-1）,m和n为两部分元素的个数,若线性表分别采用数组和链表两种方式存储,编写算法将两部分元素换位成（b0,b1,...,bm-1,a0,a1,...,an-1）,分析两种存储方式下算法的时间和空间复杂度。
9.用循环链表作线性表（a0,a1,...,an-1）和（b0,b1,...,bm-1）的存储结构,头指针分别为ah和bh，设计C函数，把两个线性表合并成形如（a0,b0,a1,b1,…）的线性表，要求不开辟新的动态空间,利用原来循环链表的结点完成合并操作,结构仍为循环链表,头指针为head,并分析算法的时间复杂度。
10.试写出将一个线性表分解为两个带有头结点的循环链表，并将两个循环链表的长度放在各自的头结点的数据域中的C函数。
其中,线性表中序号为偶数的元素分解到第一个循环链表中,序号为奇数的元素分解到第二个循环链表中。
11.试写出把线性链表改为循环链表的C函数。
12.己知非空线性链表中x结点的直接前驱结点为y,试写出删除x结点的C函数。
1.B2.C3.D4.B5.A6.A7、C
1、×
2、√3、×
4、×
5、√
1、s->
2、一定；
不一定3、n/24、q->
prior=p;
5、
（1）6）3）
（2）2）9）1）7）
四、算法设计题
1、
#include"
stdio.h"
malloc.h"
typedefstructnode
{intdata;
structnode*link;
}NODE;
intaver（NODE*head）
{inti=0,sum=0,ave;
NODE*p;
p=head;
while（p!
=NULL）
{p=p->
link;
++i;
sum=sum+p->
data;
}
ave=sum/i;
return（ave）;
2、
{
intdata;
/*假设数据域为整型*/
voiddel_link（NODE*head,intx）/*删除数据域为x的结点*/
NODE*p,*q,*s;
q=head->
while（q!
=head）
{if（q->
data==x）
{p->
link=q->
s=q;
q=q->
free（s）;
}
else
p=q;
3、
voiddel（NODE*head,floatprice,intnum）
while（q->
price<
price&
&
q!
if（q->
price==price）
num=q->
num-num;
else
printf（"
无此产品"
）;
num==0）
free（q）;
4、
floatprice;
intnum;
structnode*next;
voidins（NODE*head,floatprice,intnum）
num+num;
s=（NODE*）malloc（sizeof（NODE））;
price=price;
num=num;
5、顺序表：
算法思想：
从0开始扫描线性表，用k记录下元素值在a与b之间的元素个数，对于不满足该条件的元素，前移k个位置，最后修改线性表的长度。
voiddel（elemtypelist[]，int*n，elemtypea，elemtypeb）
inti=0，k=0；
while（i<
n）
if（list[i]>
=a&
list[i]<
=b）k++;
list[i-k]=list[i];
i++;
*n=*n-k;
/*修改线性表的长度*/
循环链表:
voiddel（NODE*head,elemtypea,elemtypeb）
NODE*p,*q;
p=head;
q=p->
/*假设循环链表带有头结点*/
=head&
q->
data<
a）
b）
r=q;
free（r）;
if（p!
=q）
link=q;
6、
#defineMAXSIZE100
intlistA[MAXSIZE],listB[MAXSIZE];
intn,m;
intcompare（inta[],intb[]）
inti=0;
while（a[i]==b[i]&
n&
m）
if（n==m&
i==n）return（0）;
if（n<
m&
i==n）return（-1）;
if（n>
i==m）return
（1）;
if（i<
if（a[i]<
b[i]）return（-1）;
elseif（a[i]>
b[i]）return
（1）;
7、
voiddel（DUNODE **head,inti）
DUNODE*p;
if（i==0）
*head=*head->
*head->
prior=NULL;
return（0）;
}
Else
{for（j=0;
i&
p!
=NULL;
j++）
p=p->
if（p==NULL||j>
i）return
（1）;
prior=p->
proir;
free（p）;
8.
顺序存储:
voidconvert（elemtypelist[],intl,inth）/*将数组中第l个到第h个元素逆置*/
inti;
elemtypetemp;
for（i=h;
=（l+h）/2;
i++）
temp=list[i];
list[i]=list[l+h-i];
list[l+h-i]=temp;
voidexchange（elemtypelist[],intn,intm）;
convert（list,0,n+m-1）;
convert（list,0,m-1）;
convert（list,m,n+m-1）;
该算法的时间复杂度为O（n+m）,空间复杂度为O
（1）
链接存储:
（不带头结点的单链表）
elemtypedata;
voidconvert（NODE**head,intn,intm）
NODE*p,*q,*r;
p=*head;
q=*head;
for（i=0;
n-1;
/*q指向an-1结点*/
r=q->
link=NULL;
while（r->
link!
r=r->
/*r指向最后一个bm-1结点*/
*head=q;
r->
link=p;
该算法的时间复杂度为O（n+m）,但比顺序存储节省时间（不需要移动元素,只需改变指针）,空间复杂度为O
（1）
9.
NODE *union（NODE *ah,NODE*bh）
NODE *a,*b,*head,*r,*q;
head=ah;
a=ah;
b=bh;
while（a->
=ah&
b->
=bh）
r=a->
q=b->
a->
link=b;
link=r;
a=r;
b=q;
if（a->
link==ah）/*a的结点个数小于等于b的结点个数*/
while（b->
b=b->
link=head;
if（b->
link==bh）/*b的结点个数小于a的结点个数*/
{
return（head）;
该算法的时间复杂度为O（n+m）,其中n和m为两个循环链表的结点个数.
10.
voidanalyze（NODE*a）
NODE *rh，*qh，*r,*q,*p；
inti=0，j=0；
/*i为序号是奇数的结点个数j为序号是偶数的结点个数*/
p=a；
rh=（NODE*）malloc（sizeof（NODE））；
/*rh为序号是奇数的链表头指针*/
qh=（NODE*）malloc（sizeof（NODE））;
/*qh为序号是偶数的链表头指针*/
r=rh;
q=qh;
r=p;
q=p;
j++;
rh->
data=i;
link=rh;
qh->
data=j;
link=qh;
11.
voidchange（NODE *head）
NODE *p;
if（head!
while（p->
12.
voiddel（NODE*x,NODE*y）
elemtyped1;
p=y;
q=x;
=NULL）/*把后一个结点数据域前移到前一个结点*/
data=q->
/*删除最后一个结点*/
第三章栈和队列
1.一个栈的入栈序列是a,b,c,d,e,则栈的不可能的输出序列是（）。
（A）edcba（B）decba（C）dceab（D）abcde
2.栈结构通常采用的两种存储结构是（）。
（A）线性存储结构和链表存储结构（B）散列方式和索引方式
（C）链表存储结构和数组（D）线性存储结构和非线性存储结构
3.判定一个栈ST（最多元素为m0）为空的条件是（）。
（A）ST-〉top!
=0（B）ST-〉top==0
（C）ST-〉top!
=m0（D）ST-〉top=m0
4.判定一个栈ST（最多元素为m0）为栈满的条件是（）。
（A）ST->
top!
=0（B）ST->
top==0
（C）ST->
=m0-1（D）ST->
top==m0-1
5.一个队列的入列序列是1,2,3,4,则队列的输出序列是（）。
（A）4,3,2,1（B）1,2,3,4（C）1,4,3,2（D）3,2,4,1
6.循环队列用数组A[0,m-1]存放其元素值,已知其头尾指针分别是front和rear则当前队列中的元素个数是（）
（A）（rear-front+m）%m（B）rear-front+1（C）rear-front-1（D）rear-front
7.栈和队列的共同点是（）
（A）都是先进后出（B）都是先进先出
（C）只允许在端点处插入和删除元素（D）没有共同点
8.表达式a*（b+c）-d的后缀表达式是（）。
升级会员 