数据结构C语言版第版习题答案严蔚敏.docx

数据结构C语言版第版习题答案严蔚敏.docx

《数据结构C语言版第版习题答案严蔚敏.docx》由会员分享，可在线阅读，更多相关《数据结构C语言版第版习题答案严蔚敏.docx（88页珍藏版）》请在冰豆网上搜索。

数据结构C语言版第版习题答案严蔚敏

数据结构（C语言版）（第2版）

课后习题答案

李冬梅

2015.3

第1章绪论1

第2章线性表5

第3章栈和队列13

第4章串、数组和广义表26

第5章树和二叉树33

第6章图43

第7章查找54

第8章排序65

第1章绪论

1．简述下列概念：

数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。

答案：

数据：

是客观事物的符号表示，指所有能输入到计算机中并被计算机程序处理的符号的总称。

如数学计算中用到的整数和实数，文本编辑所用到的字符串，多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。

数据元素：

是数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。

在有些情况下，数据元素也称为元素、结点、记录等。

数据元素用于完整地描述一个对象，如一个学生记录，树中棋盘的一个格局（状态）、图中的一个顶点等。

数据项：

是组成数据元素的、有独立含义的、不可分割的最小单位。

例如，学生基本信息表中的学号、姓名、性别等都是数据项。

数据对象：

是性质相同的数据元素的集合，是数据的一个子集。

例如：

整数数据对象是集合N={0，±1，±2，…}，字母字符数据对象是集合C={‘A’，‘B’，…，‘Z’，‘a’，‘b’，…，‘z’}，学生基本信息表也可是一个数据对象。

数据结构：

是相互之间存在一种或多种特定关系的数据元素的集合。

换句话说，数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。

逻辑结构：

从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。

因此，数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。

存储结构：

数据对象在计算机中的存储表示，也称为物理结构。

抽象数据类型：

由用户定义的，表示应用问题的数学模型，以及定义在这个模型上的一组操作的总称。

具体包括三部分：

数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。

2．试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。

答案：

例如有一张学生基本信息表，包括学生的学号、姓名、性别、籍贯、专业等。

每个学生基本信息记录对应一个数据元素，学生记录按顺序号排列，形成了学生基本信息记录的线性序列。

对于整个表来说，只有一个开始结点（它的前面无记录）和一个终端结点（它的后面无记录），其他的结点则各有一个也只有一个直接前趋和直接后继。

学生记录之间的这种关系就确定了学生表的逻辑结构，即线性结构。

这些学生记录在计算机中的存储表示就是存储结构。

如果用连续的存储单元（如用数组表示）来存放这些记录，则称为顺序存储结构；如果存储单元不连续，而是随机存放各个记录，然后用指针进行链接，则称为链式存储结构。

即相同的逻辑结构，可以对应不同的存储结构。

3．简述逻辑结构的四种基本关系并画出它们的关系图。

答案：

（1）集合结构

数据元素之间除了“属于同一集合”的关系外，别无其他关系。

例如，确定一名学生是否为班级成员，只需将班级看做一个集合结构。

（2）线性结构

数据元素之间存在一对一的关系。

例如，将学生信息数据按照其入学报到的时间先后顺序进行排列，将组成一个线性结构。

（3）树结构

数据元素之间存在一对多的关系。

例如，在班级的管理体系中，班长管理多个组长，每位组长管理多名组员，从而构成树形结构。

（4）图结构或网状结构

数据元素之间存在多对多的关系。

例如，多位同学之间的朋友关系，任何两位同学都可以是朋友，从而构成图形结构或网状结构。

其中树结构和图结构都属于非线性结构。

四类基本逻辑结构关系图

4．存储结构由哪两种基本的存储方法实现？

答案：

（1）顺序存储结构

顺序存储结构是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系，通常借助程序设计语言的数组类型来描述。

（2）链式存储结构

顺序存储结构要求所有的元素依次存放在一片连续的存储空间中，而链式存储结构，无需占用一整块存储空间。

但为了表示结点之间的关系，需要给每个结点附加指针字段，用于存放后继元素的存储地址。

所以链式存储结构通常借助于程序设计语言的指针类型来描述。

5．选择题

（1）在数据结构中，从逻辑上可以把数据结构分成（）。

A．动态结构和静态结构B．紧凑结构和非紧凑结构

C．线性结构和非线性结构D．内部结构和外部结构

答案：

C

（2）与数据元素本身的形式、内容、相对位置、个数无关的是数据的（）。

A．存储结构B．存储实现

C．逻辑结构D．运算实现

答案：

C

（3）通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（）。

A．数据具有同一特点

B．不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致

C．每个数据元素都一样

D．数据元素所包含的数据项的个数要相等

答案：

B

（4）以下说法正确的是（）。

A．数据元素是数据的最小单位

B．数据项是数据的基本单位

C．数据结构是带有结构的各数据项的集合

D．一些表面上很不相同的数据可以有相同的逻辑结构

答案：

D

解释：

数据元素是数据的基本单位，数据项是数据的最小单位，数据结构是带有结构的各数据元素的集合。

（5）算法的时间复杂度取决于（）。

A．问题的规模B．待处理数据的初态

C．计算机的配置D．A和B

答案：

D

解释：

算法的时间复杂度不仅与问题的规模有关，还与问题的其他因素有关。

如某些排序的算法，其执行时间与待排序记录的初始状态有关。

为此，有时会对算法有最好、最坏以及平均时间复杂度的评价。

（6）以下数据结构中，（）是非线性数据结构

A．树B．字符串C．队列D．栈

答案：

A

6．试分析下面各程序段的时间复杂度。

（1）x=90;y=100;

while（y>0）

if（x>100）

{x=x-10;y--;}

elsex++;

答案：

O

（1）

解释：

程序的执行次数为常数阶。

（2）for（i=0;i

for（j=0;j

a[i][j]=0;

答案：

O（m*n）

解释：

语句a[i][j]=0;的执行次数为m*n。

（3）s=0;

fori=0;i

for（j=0;j

s+=B[i][j];

sum=s;

答案：

O（n2）

解释：

语句s+=B[i][j];的执行次数为n2。

（4）i=1;

while（i<=n）

i=i*3;

答案：

O（log3n）

解释：

语句i=i*3;的执行次数为log3n。

（5）x=0;

for（i=1;i

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

x++;

答案：

O（n2）

解释：

语句x++;的执行次数为n-1+n-2+……＋1=n（n-1）/2。

（6）x=n;//n>1

y=0;

while（x≥（y+1）*（y+1））

y++;

答案：

O（

）

解释：

语句y++;的执行次数为

。

第2章线性表

1．选择题

（1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（）。

A．110B．108C．100D．120

答案：

B

解释：

顺序表中的数据连续存储，所以第5个元素的地址为：

100+2*4=108。

（2）在n个结点的顺序表中，算法的时间复杂度是O

（1）的操作是（）。

A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n）

B．在第i个结点后插入一个新结点（1≤i≤n）

C．删除第i个结点（1≤i≤n）

D．将n个结点从小到大排序

答案：

A

解释：

在顺序表中插入一个结点的时间复杂度都是O（n2），排序的时间复杂度为O（n2）或O（nlog2n）。

顺序表是一种随机存取结构，访问第i个结点和求第i个结点的直接前驱都可以直接通过数组的下标直接定位，时间复杂度是O

（1）。

（3）向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动的元素个数为（）。

A．8B．63.5C．63D．7

答案：

B

解释：

平均要移动的元素个数为：

n/2。

（4）链接存储的存储结构所占存储空间（）。

A．分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针

B．只有一部分，存放结点值

C．只有一部分，存储表示结点间关系的指针

D．分两部分，一部分存放结点值，另一部分存放结点所占单元数

答案：

A

（5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（）。

A．必须是连续的B．部分地址必须是连续的

C．一定是不连续的D．连续或不连续都可以

答案：

D

（6）线性表Ｌ在（）情况下适用于使用链式结构实现。

A．需经常修改Ｌ中的结点值Ｂ．需不断对Ｌ进行删除插入

C．Ｌ中含有大量的结点Ｄ．Ｌ中结点结构复杂

答案：

B

解释：

链表最大的优点在于插入和删除时不需要移动数据，直接修改指针即可。

（7）单链表的存储密度（）。

A．大于1B．等于1C．小于1D．不能确定

答案：

C

解释：

存储密度是指一个结点数据本身所占的存储空间和整个结点所占的存储空间之比，假设单链表一个结点本身所占的空间为D，指针域所占的空间为N，则存储密度为：

D/（D+N），一定小于1。

（8）将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是（）。

A．nB．2n-1C．2nD．n-1

答案：

A

解释：

当第一个有序表中所有的元素都小于（或大于）第二个表中的元素，只需要用第二个表中的第一个元素依次与第一个表的元素比较，总计比较n次。

（9）在一个长度为n的顺序表中，在第i个元素（1≤i≤n+1）之前插入一个新元素时须向后移动（）个元素。

A．n-iB．n-i+1C．n-i-1D．I

答案：

B

（10）线性表L=（a1，a2,……an），下列说法正确的是（）。

A．每个元素都有一个直接前驱和一个直接后继

B．线性表中至少有一个元素

C．表中诸元素的排列必须是由小到大或由大到小

D．除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。

答案：

D

（11）创建一个包括n个结点的有序单链表的时间复杂度是（）。

A．O

（1）B．O（n）C．O（n2）D．O（nlog2n）

答案：

C

解释：

单链表创建的时间复杂度是O（n），而要建立一个有序的单链表，则每生成一个新结点时需要和已有的结点进行比较，确定合适的插入位置，所以时间复杂度是O（n2）。

（12）以下说法错误的是（）。

A．求表长、定位这两种运算在采用顺序存储结构时实现的效率不比采用链式存储结构时实现的效率低

B．顺序存储的线性表可以随机存取

C．由于顺序存储要求连续的存储区域，所以在存储管理上不够灵活

D．线性表的链式存储结构优于顺序存储结构

答案：

D

解释：

链式存储结构和顺序存储结构各有优缺点，有不同的适用场合。

（13）在单链表中，要将s所指结点插入到p所指结点之后，其语句应为（）。

A．s->next=p+1;p->next=s;

B．（*p）.next=s;（*s）.next=（*p）.next;

C．s->next=p->next;p->next=s->next;

D．s->next=p->next;p->next=s;

答案：

D

（14）在双向链表存储结构中，删除p所指的结点时须修改指针（）。

A．p->next->prior=p->prior;p->prior->next=p->next;

B．p->next=p->next->next;p->next->prior=p;

C．p->prior->next=p;p->prior=p->prior->prior;

D．p->prior=p->next->next;p->next=p->prior->prior;

答案：

A

（15）在双向循环链表中，在p指针所指的结点后插入q所指向的新结点，其修改指针的操作是（）。

A．p->next=q;q->prior=p;p->next->prior=q;q->next=q;

B．p->next=q;p->next->prior=q;q->prior=p;q->next=p->next;

C．q->prior=p;q->next=p->next;p->next->prior=q;p->next=q;

D．q->prior=p;q->next=p->next;p->next=q;p->next->prior=q;

答案：

C

2．算法设计题

（1）将两个递增的有序链表合并为一个递增的有序链表。

要求结果链表仍使用原来两个链表的存储空间,不另外占用其它的存储空间。

表中不允许有重复的数据。

[题目分析]

合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的最后。

如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素，这样确保合并后表中无重复的元素。

当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在Lc表的最后。

[算法描述]

voidMergeList（LinkList&La,LinkList&Lb,LinkList&Lc）

{//合并链表La和Lb，合并后的新表使用头指针Lc指向

pa=La->next;pb=Lb->next;

//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点

Lc=pc=La;//用La的头结点作为Lc的头结点

while（pa&&pb）

{if（pa->datadata）{pc->next=pa;pc=pa;pa=pa->next;}

//取较小者La中的元素，将pa链接在pc的后面，pa指针后移

elseif（pa->data>pb->data）{pc->next=pb;pc=pb;pb=pb->next;}

//取较小者Lb中的元素，将pb链接在pc的后面，pb指针后移

else//相等时取La中的元素，删除Lb中的元素

{pc->next=pa;pc=pa;pa=pa->next;

q=pb->next;deletepb;pb=q;

}

}

pc->next=papa:

pb;//插入剩余段

deleteLb;//释放Lb的头结点

}

（2）将两个非递减的有序链表合并为一个非递增的有序链表。

要求结果链表仍使用原来两个链表的存储空间,不另外占用其它的存储空间。

表中允许有重复的数据。

[题目分析]

合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的表头结点之后，如果两个表中的元素相等，只摘取La表中的元素，保留Lb表中的元素。

当一个表到达表尾结点，为空时，将非空表的剩余元素依次摘取，链接在Lc表的表头结点之后。

[算法描述]

voidMergeList（LinkList&La,LinkList&Lb,LinkList&Lc,）

{//合并链表La和Lb，合并后的新表使用头指针Lc指向

pa=La->next;pb=Lb->next;

//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点

Lc=pc=La;//用La的头结点作为Lc的头结点

Lc->next=NULL;

while（pa||pb）

{//只要存在一个非空表，用q指向待摘取的元素

if（!

pa）{q=pb;pb=pb->next;}

//La表为空，用q指向pb，pb指针后移

elseif（!

pb）{q=pa;pa=pa->next;}

//Lb表为空，用q指向pa，pa指针后移

elseif（pa->data<=pb->data）{q=pa;pa=pa->next;}

//取较小者（包括相等）La中的元素，用q指向pa，pa指针后移

else{q=pb;pb=pb->next;}

//取较小者Lb中的元素，用q指向pb，pb指针后移

q->next=Lc->next;Lc->next=q;

//将q指向的结点插在Lc表的表头结点之后

}

deleteLb;//释放Lb的头结点

}

（3）已知两个链表A和B分别表示两个集合，其元素递增排列。

请设计算法求出A与B的交集，并存放于A链表中。

[题目分析]

只有同时出现在两集合中的元素才出现在结果表中,合并后的新表使用头指针Lc指向。

pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，如果两个表中相等的元素时，摘取La表中的元素，删除Lb表中的元素；如果其中一个表中的元素较小时，删除此表中较小的元素，此表的工作指针后移。

当链表La和Lb有一个到达表尾结点，为空时，依次删除另一个非空表中的所有元素。

[算法描述]

voidMix（LinkList&La,LinkList&Lb,LinkList&Lc）

{pa=La->next;pb=Lb->next;

pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点

Lc=pc=La;//用La的头结点作为Lc的头结点

while（pa&&pb）

{

if（pa->data==pb->data）∥交集并入结果表中。

{

pc->next=pa;

pc=pa;pa=pa->next;

u=pb;pb=pb->next;

Deleteu;

}

elseif（pa->datadata）

{

u=pa;pa=pa->next;deleteu;

}

else

{

u=pb;pb=pb->next;deleteu;

}

}

while（pa）{u=pa;pa=pa->next;deleteu;}∥释放结点空间

while（pb）{u=pb;pb=pb->next;deleteu;}∥释放结点空间

pc->next=null;∥置链表尾标记。

deleteLb;//释放Lb的头结点

}

（4）已知两个链表A和B分别表示两个集合，其元素递增排列。

请设计算法求出两个集合A和B的差集（即仅由在A中出现而不在B中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合的元素个数。

[题目分析]

求两个集合A和B的差集是指在A中删除A和B中共有的元素，即删除链表中的相应结点,所以要保存待删除结点的前驱，使用指针pre指向前驱结点。

pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，如果La表中的元素小于Lb表中的元素，pre置为La表的工作指针pa删除Lb表中的元素；如果其中一个表中的元素较小时，删除此表中较小的元素，此表的工作指针后移。

当链表La和Lb有一个为空时，依次删除另一个非空表中的所有元素。

[算法描述]

voidDifference（LinkList&La,LinkList&Lb,int*n）

{∥差集的结果存储于单链表La中，*n是结果集合中元素个数，调用时为0

pa=La->next;pb=Lb->next;

∥pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点

pre=La;∥pre为La中pa所指结点的前驱结点的指针

while（pa&&pb）

{if（pa->datadata）{pre=pa;pa=pa->next;*n++;}

∥A链表中当前结点指针后移

elseif（pa->data>q->data）q=q->next;∥B链表中当前结点指针后移

else{pre->next=pa->next;∥处理A，B中元素值相同的结点，应删除

u=pa;pa=pa->next;deleteu;}∥删除结点

}

}

（5）设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点（链表A中的元素为非零整数，要求B、C表利用A表的结点）。

[题目分析]

B表的头结点使用原来A表的头结点，为C表新申请一个头结点。

从A表的第一个结点开始，依次取其每个结点p，判断结点p的值是否小于0，利用前插法，将小于0的结点插入B表,大于等于0的结点插入C表。

[算法描述]

voidDisCompose（LinkedListA）

{B=A;

B->next=NULL;∥B表初始化

C=newLNode;∥为C申请结点空间

C->next=NULL;∥C初始化为空表

p=A->next;∥p为工作指针

while（p!

=NULL）

{r=p->next;∥暂存p的后继

if（p->data<0）

{p->next=B->next;B->next=p;}∥将小于0的结点链入B表,前插法

else{p->next=C->next;C->next=p;}∥将大于等于0的结点链入C表,前插法

p=r;∥p指向新的待处理结点。

}

}

（6）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。

[题目分析]

假定第一个结点中数据具有最大值，依次与下一个元素比较，若其小于下一个元素，则设其下一个元素为最大值，反复进行比较，直到遍历完该链表。

[算法描述]

ElemTypeMax（LinkListL）{

if（L->next==NULL）returnNULL;

pmax=L->next;//假定第一个结点中数据具有最大值

p=L->next->next;

while（p!

=NULL）{//如果下一个结点存在

if（p->data>pmax->data）pmax=p;//如果p的值大于pmax的值，则重新赋值

p=p->next;//遍历链表

}

returnpmax->data;

（7）设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。

[题目分析]

从首元结点开始，逐个地把链表L的当前结点p插入新的链表头部。

[算法描述]

voidinverse（LinkList&L）

{//逆置带头结点的单链表L

p=L->next;L->next=NULL;

while（p）{

q=p->next;//q指向*p的后继

p->next=L->next;

L->next=p;//*p插入在头结点之后

p=q;

}

}

（8）设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（