数据结构及应用算法 课后复习题附答案 严蔚敏版Word文档下载推荐.docx
《数据结构及应用算法 课后复习题附答案 严蔚敏版Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《数据结构及应用算法 课后复习题附答案 严蔚敏版Word文档下载推荐.docx（15页珍藏版）》请在冰豆网上搜索。
e）Min（C,&
用e返回复数C的两个元素中值较小的一个 }ADTComplex ADTRationalNumber{ 数据对象：
D={s,m|s,m为自然数，且m不为0}数据关系：
InitRationalNumber（&
R,s,m） 操作结果：
构造一个有理数R，其分子和分母分别为s和mDestroyRationalNumber（&
R） 操作结果：
销毁有理数R Get（R,k,&
用e返回有理数R的第k元的值操作结果：
改变有理数R的第k元的值为ePut（&
R,k,e） IsAscending（R） 操作结果：
若有理数R的两个元素按升序排列，则返回1，否则返回0操作结果：
若有理数R的两个元素按降序排列，则返回1，否则返回0 IsDescending（R）Max（R,&
用e返回有理数R的两个元素中值较大的一个 Min（R,&
用e返回有理数R的两个元素中值较小的一个 }ADTRationalNumber 试画出与下列程序段等价的框图。
（1）product=1;
i=1;
while（i }while（（i!
=n）&
&
（a[i]!
=x））;
（3）switch{ casex 在程序设计中，常用下列三种不同的出错处理方式：
（1）用exit语句终止执行并报告错误；
（2）以函数的返回值区别正确返回或错误返回；
（3）设置一个整型变量的函数参数以区别正确返回或某种错误返回。
试讨论这三种方法各自的优缺点。
（1）exit常用于异常错误处理，它可以强行中断程序的执行，返回操作系统。
（2）以函数的返回值判断正确与否常用于子程序的测试，便于实现程序的局部控制。
（3）用整型函数进行错误处理的优点是可以给出错误类型，便于迅速确定错误。
在程序设计中，可采用下列三种方法实现输出和输入：
（1）通过scanf和printf语句；
（2）通过函数的参数显式传递；
（3）通过全局变量隐式传递。
试讨论这三种方法的优缺点。
（1）用scanf和printf直接进行输入输出的好处是形象、直观，但缺点是需要对其进行格式控制，较为烦琐，如果出现错误，则会引起整个系统的崩溃。
（2）通过函数的参数传递进行输入输出，便于实现信息的隐蔽，减少出错的可能。
（3）通过全局变量的隐式传递进行输入输出最为方便，只需修改变量的值即可，但过多的全局变量使程序的维护较为困难。
设n为正整数。
试确定下列各程序段中前置以记号@的语句的频度：
（1）i=1;
k=0;
while（i
（2）i=1;
do{ @k+=10*i;
i++;
}while（i @k+=10*i;
}（4）k=0;
for（i=1;
i （5）for（i=1;
i （6）i=1;
j=0;
while（i+jj）j++;
elsei++;
} （7）x=n;
y=0;
//n是不小于1的常数 while（x>
=（y+1）*（y+1））{ @y++;
} （8）x=91;
y=100;
while（y>
0）{ @if（x>
100）{x-=10;
y--;
} elsex++;
}解：
（1）n-1
（2）n-1 （3）n-1 （4）n+（n-1）+（n-2）+...+1= n（n?
1）2 n （5）1+（1+2）+（1+2+3）+...+（1+2+3+...+n）= ?
i?
1ni（i?
1）21n = 1ni（i?
1）?
（i?
22i?
1i?
11n2?
i）?
2i?
12?
i?
1 = 112n（n?
1）（2n?
14n（n?
112n（n?
3） （6）n （7） ?
n?
向下取整 （8）1100 假设n为2的乘幂，并且n>
2，试求下列算法的时间复杂度及变量count的值。
intTime（intn）{ }解：
o（logcount=log2 count=0;
x=2;
while（x x*=2;
count++;
returncount;
n）n?
2 已知有实现同一功能的两个算法，其时间复杂度分别为O2?
和O?
，假设现实计算机可连续 n10 运算的时间为10秒，又每秒可执行基本操作10次。
试问在此条件下，这两个算法可解问题的规模各为多少？
哪个算法更适宜？
请说明理。
2n75?
101012 12n=40 n?
10n=16 则对于同样的循环次数n，在这个规模下，第二种算法所花费的代价要大得多。
故在这个规模下，第一种算法更适宜。
设有以下三个函数：
f?
21n4?
1000，g?
15n?
500n，h?
nlogn 请判断以下断言正确与否：
（1）f（n）是O（g（n））
（2）h（n）是O（f（n））（3）g（n）是O（h（n））（4）h（n）是O（n）（5）h（n）是O（nlogn） 解：
（1）对
（2）错（3）错（4）对（5）错试设定若干n值，比较两函数n和50nlog大于 2n的增长趋势，并确定n在什么范围内，函数n的值 22n的值。
n的值较大。
n的增长趋势快。
但在n较小的时候，50nlog 当n>
438时，n22?
50nlog2n 判断下列各对函数f?
和g?
，当n?
时，哪个函数增长更快？
（1）f?
10n2?
lnn!
102?
n3?
，g?
7
（2）f?
ln?
n!
5?
13n（3）f?
n（4）f?
2?
1，g?
n 4n?
3?
2?
2，g?
n 5解：
（1）g（n）快
（2）g（n）快（3）f（n）快（4）f（n）快试用数学归纳法证明：
n
（1） ?
ii?
1n2?
1?
2n?
/6?
0?
（2） ?
xi?
0i?
x?
1/?
1,n?
n（3） ?
1ni?
1n?
1 ?
?
（4） ?
ni?
12 试写一算法，自大至小依次输出顺序读入的三个整数X，Y和Z的值 解：
intmax3（intx,inty,intz）{ } 已知k阶斐波那契序列的定义为 if（x>
y） if（x>
z）returnx;
elsereturnz;
if（y>
z）returny;
else f0?
0，f1?
0，…，fk?
0，fk?
1；
fn?
fn?
k，n?
k,k?
1,?
试编写求k阶斐波那契序列的第m项值的函数算法，k和m均以值调用的形式在函数参数表中出现。
k>
0为阶数，n为数列的第n项intFibonacci（intk,intn）{ } 假设有A，B，C，D，E五个高等院校进行田径对抗赛，各院校的单项成绩均已存入计算机，并构成一张表，表中每一行的形式为 if（k for（i=0;
i } for（i=k+1;
i returnp[k];
x=p[0];
for（j=0;
j 项目名称性别校名成绩得分编写算法，处理上述表格，以统计各院校的男、女总分和团体总分，并输出。
typedefenum{A,B,C,D,E}SchoolName;
typedefenum{Female,Male}SexType;
typedefstruct{ charevent[3];
//项目SexTypesex;
SchoolNameschool;
intscore;
}Component;
typedefstruct{ intMaleSum;
intFemaleSum;
//男团总分//女团总分 intTotalSum;
//团体总分 }Sum;
SumSumScore（SchoolNamesn,Componenta,intn）{ } 试编写算法，计算i!
*2的值并存入数组a[0..arrsize-1]的第i-1个分量中（i=1,2,…,n）。
假设计算机中允许的整数最大值为maxint，则当n>
arrsize或对某个k?
k?
，使k!
2应按出错处理。
注意选择你认为较好的出错处理方法。
#include#include#defineMAXINT65535#defineArrSize100intfun（inti）;
kiSumtemp;
=0;
inti;
for（i=0;
i =+;
returntemp;
if（a[i].school==sn）{} if（a[i].sex==Male）+=a[i].score;
if（a[i].sex==Female）+=a[i].score;
maxint时， intmain（）{ } 试编写算法求一元多项式的值Pn?
ninti,k;
inta[ArrSize];
cout>
k;
if（k>
ArrSize-1）exit（0）;
for（i=0;
i for（i=0;
i return0;
if（a[i]>
MAXINT）exit（0）;
elsecout if（2*i*a[i-1]>
elsea[i]=2*i*a[i-1];
ai?
0iix的值Pn?
x0?
，并确定算法中每一语句的执行次数 和整个算法的时间复杂度。
注意选择你认为较好的输入和输出方法。
本题的输入为ai?
0,1,?
n?
，x0和n，输出为Pn?
。
#include#include#defineN10 doublepolynomail（inta,inti,doublex,intn）;
intmain（）{ doublex;
intn,i;
inta[N];
cout>
x;
n;
if（n>
N-1）exit（0）;
a[i];
} cout doublepolynomail（inta,inti,doublex,intn）{} 本算法的时间复杂度为o（n）。
if（i>
0）returna[n-i]+polynomail（a,i-1,x,n）*x;
elsereturna[n];
第2章线性表 描述以下三个概念的区别：
头指针，头结点，首元结点。
头指针是指向链表中第一个结点的指针。
首元结点是指链表中存储第一个数据元素的结点。
头结点是在首元结点之前附设的一个结点，该结点不存储数据元素，其指针域指向首元结点，其作用主要是为了方便对链表的操作。
它可以对空表、非空表以及首元结点的操作进行统一处理。
填空题。
（1）在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与元素在表中的位置有关。
（2）顺序表中逻辑上相邻的元素的物理位置必定紧邻。
单链表中逻辑上相邻的元素的物理位置不一定紧邻。
（3）在单链表中，除了首元结点外，任一结点的存储位置其前驱结点的链域的值指示。
（4）在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。
在什么情况下用顺序表比链表好？
当线性表的数据元素在物理位置上是连续存储的时候，用顺序表比用链表好，其特点是可以进行随机存取。
对以下单链表分别执行下列各程序段，并画出结果示意图。
解：
画出执行下列各行语句后各指针及链表的示意图。
L=（LinkList）malloc（sizeof（LNode））;
for（i=1;
i P->
next=NULL;
for（i=4;
i>
=1;
i--）Ins_LinkList（L,i+1,i*2）;
next=（LinkList）malloc（sizeof（LNode））;
P=P->
next;
P->
data=i*2-1;
P=L;
已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。
a.在P结点后插入S结点的语句序列是__________________。
b.在P结点前插入S结点的语句序列是__________________。
c.在表首插入S结点的语句序列是__________________。
d.在表尾插入S结点的语句序列是__________________。
（1）P->
next=S;
（2）P->
next=P->
next->
（3）P->
next=S->
（4）S->
（5）S->
next=L;
（6）S->
（7）Q=P;
（8）while（P->
next!
=Q）P=P->
（9）while（P->
=NULL）P=P->
（10）P=Q;
（11）P=L;
（12）L=S;
（13）L=P;
解：
a.（4）
（1） b.（7）（11）（8）（4）
（1）c.（5）（12）d.（9）
（1）（6） 已知L是带表头结点的非空单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。
a.删除P结点的直接后继结点的语句序列是____________________。
b.删除P结点的直接前驱结点的语句序列是____________________。
c.删除P结点的语句序列是____________________。
d.删除首元结点的语句序列是____________________。
e.删除尾元结点的语句序列是____________________。
（1）P=P->
（2）P->
next=P;
（3）P->
（4）P=P->
（5）while（P!
（6）while（Q->
=NULL）{P=Q;
Q=Q->
}（7）while（P->
（8）while（P->
（10）Q=P;
（11）Q=P->
（12）P=L;
（13）L=L->
（14）free（Q）;
a.（11）（3）（14） b.（10）（12）（8）（3）（14）c.（10）（12）（7）（3）（14） d.（12）（11）（3）（14）e.（9）（11）（3）（14） 已知P结点是某双向链表的中间结点，试从下列提供的答案中选择合适的语句序列。
a.在P结点后插入S结点的语句序列是_______________________。
b.在P结点前插入S结点的语句序列是_______________________。
c.删除P结点的直接后继结点的语句序列是_______________________。
d.删除P结点的直接前驱结点的语句序列是_______________________。
e.删除P结点的语句序列是_______________________。
priou=P->
priou->
priou;
（4）P->
priou=S;
priou=P;
（7）S->
（8）S->
（9）P->
（10）P->
（11）P->
（12）P->
（13）P->
（14）P->
（15）Q=P->
（16）Q=P->
（17）free（P）;
（18）free（Q）;
a.（7）（3）（6）（12） b.（8）（4）（5）（13）c.（15）
（1）（11）（18）d.（16）
（2）（10）（18）e.（14）（9）（17） 简述以下算法的功能。
（1）StatusA（LinkedListL）{//L是无表头结点的单链表 } if（L&
L->
next）{ } returnOK;
Q=L;
L=L->
while（P->
next）P=P->
P->
next=Q;
Q->
（2）voidBB（LNode*s,LNode*q）{ p=s;
while（p->
=q）p=p->
p->
next=s;
} voidAA（LNode*pa,LNode*pb）{ } //pa和pb分别指向单循环链表中的两个结点BB（pa,pb）;
BB（pb,pa）;
（1）如果L的长度不小于2，将L的首元结点变成尾元结点。
（2）将单循环链表拆成两个单循环链表。
指出以下算法中的错误和低效之处，并将它改写为一个既正确又高效的算法。
StatusDeleteK（SqList&
a,inti,intk）{ //本过程从顺序存储结构的线性表a中删除第i个元素起的k个元素if（i）returnINFEASIBLE;
//参数不合法else{ for（count=1;
count }解：
a,inti,intk）{ } 设顺序表va中的数据元素递增有序。
试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性。
StatusInsertOrderList（SqList&
va,ElemTypex）{ //在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法inti;
if（==）return（OVERFLOW）;
for（i=;
0,x [i]=[i-1];
[i]=x;
//从顺序存储结构的线性表a中删除第i个元素起的k个元素//注意i的编号从0开始intj;
if（i||k）returnINFEASIBLE;
for（j=0;
j [j+i]=[j+i+k];
} //删除第一个元素 for（j=;
j>
=i+1;
j--）[j-i]=[j];
;
returnOK;
=;
returnOK;
} ++;
设A?
a1,?
am?
和B?
b1,?
bn?
均为顺序表，A?
分别为A和B中除去最大共同前缀后的子表。
若A?
B?
空表，则A?
B；
=空表，而B?
空表，或者两者均不为空表，且A?
的首元小于B?
的首元，则A?
否则A?
B。
试写一个比较A，B大小的算法。
StatusCompareOrderList（SqList&
A,SqList&
B）{ } 试写一算法在带头结点的单链表结构上实现线性表操作Locate（L,x）;
intLocateElem_L（LinkList&
L,ElemTypex）{ } 试写一算法在带头结点的单链表结构上实现线性表操作Length（L）。
//返回单链表的长度 intListLength_L（LinkList&
L）{ inti=0;
LinkListp=L;
if（p）p=p-next;
while
升级会员 