数据结构C语言版题集答案打印版.docx
《数据结构C语言版题集答案打印版.docx》由会员分享，可在线阅读，更多相关《数据结构C语言版题集答案打印版.docx（22页珍藏版）》请在冰豆网上搜索。
数据结构C语言版题集答案打印版
数据结构（c语言版）习题集答案
第1章绪论
1.1简述下列术语：
数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解：
数据是对客观事物的符号表示。
在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。
数据对象是性质相同的数据元素的集合，是数据的一个子集。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。
抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。
是对一般数据类型的扩展。
1.2试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解：
抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。
一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。
在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。
1.3设有数据结构（D,R），其中
，
，
试按图论中图的画法惯例画出其逻辑结构图。
解：
第2章线性表
2.1描述以下三个概念的区别：
头指针，头结点，首元结点（第一个元素结点）。
解：
头指针是指向链表中第一个结点的指针。
首元结点是指链表中存储第一个数据元素的结点。
头结点是在首元结点之前附设的一个结点，该结点不存储数据元素，其指针域指向首元结点，其作用主要是为了方便对链表的操作。
它可以对空表、非空表以及首元结点的操作进行统一处理。
2.2填空题。
解：
（1）在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与元素在表中的位置有关。
（2）顺序表中逻辑上相邻的元素的物理位置必定紧邻。
单链表中逻辑上相邻的元素的物理位置不一定紧邻。
（3）在单链表中，除了首元结点外，任一结点的存储位置由其前驱结点的链域的值指示。
（4）在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。
2.3在什么情况下用顺序表比链表好？
解：
当线性表的数据元素在物理位置上是连续存储的时候，用顺序表比用链表好，其特点是可以进行随机存取。
2.4对以下单链表分别执行下列各程序段，并画出结果示意图。
解：
2.5画出执行下列各行语句后各指针及链表的示意图。
L=（LinkList）malloc（sizeof（LNode））;P=L;
for（i=1;i<=4;i++）{
P->next=（LinkList）malloc（sizeof（LNode））;
P=P->next;P->data=i*2-1;
}
P->next=NULL;
for（i=4;i>=1;i--）Ins_LinkList（L,i+1,i*2）;
for（i=1;i<=3;i++）Del_LinkList（L,i）;
解：
2.6已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。
a.在P结点后插入S结点的语句序列是__________________。
b.在P结点前插入S结点的语句序列是__________________。
c.在表首插入S结点的语句序列是__________________。
d.在表尾插入S结点的语句序列是__________________。
（1）P->next=S;
（2）P->next=P->next->next;
（3）P->next=S->next;
（4）S->next=P->next;
（5）S->next=L;
（6）S->next=NULL;
（7）Q=P;
（8）while（P->next!
=Q）P=P->next;
（9）while（P->next!
=NULL）P=P->next;
（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）
2.7已知L是带表头结点的非空单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。
a.删除P结点的直接后继结点的语句序列是____________________。
b.删除P结点的直接前驱结点的语句序列是____________________。
c.删除P结点的语句序列是____________________。
d.删除首元结点的语句序列是____________________。
e.删除尾元结点的语句序列是____________________。
（1）P=P->next;
（2）P->next=P;
（3）P->next=P->next->next;
（4）P=P->next->next;
（5）while（P!
=NULL）P=P->next;
（6）while（Q->next!
=NULL）{P=Q;Q=Q->next;}
（7）while（P->next!
=Q）P=P->next;
（8）while（P->next->next!
=Q）P=P->next;
（9）while（P->next->next!
=NULL）P=P->next;
（10）Q=P;
（11）Q=P->next;
（12）P=L;
（13）L=L->next;
（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）
2.8已知P结点是某双向链表的中间结点，试从下列提供的答案中选择合适的语句序列。
a.在P结点后插入S结点的语句序列是_______________________。
b.在P结点前插入S结点的语句序列是_______________________。
c.删除P结点的直接后继结点的语句序列是_______________________。
d.删除P结点的直接前驱结点的语句序列是_______________________。
e.删除P结点的语句序列是_______________________。
（1）P->next=P->next->next;
（2）P->priou=P->priou->priou;
（3）P->next=S;
（4）P->priou=S;
（5）S->next=P;
（6）S->priou=P;
（7）S->next=P->next;
（8）S->priou=P->priou;
（9）P->priou->next=P->next;
（10）P->priou->next=P;
（11）P->next->priou=P;
（12）P->next->priou=S;
（13）P->priou->next=S;
（14）P->next->priou=P->priou;
（15）Q=P->next;
（16）Q=P->priou;
（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）
2.9简述以下算法的功能。
（1）StatusA（LinkedListL）{//L是无表头结点的单链表
if（L&&L->next）{
Q=L;L=L->next;P=L;
while（P->next）P=P->next;
P->next=Q;Q->next=NULL;
}
returnOK;
}
（2）voidBB（LNode*s,LNode*q）{
p=s;
while（p->next!
=q）p=p->next;
p->next=s;
}
voidAA（LNode*pa,LNode*pb）{
//pa和pb分别指向单循环链表中的两个结点
BB（pa,pb）;
BB（pb,pa）;
}
解：
（1）如果L的长度不小于2，将L的首元结点变成尾元结点。
（2）将单循环链表拆成两个单循环链表。
2.14试写一算法在带头结点的单链表结构上实现线性表操作Length（L）。
解：
//返回单链表的长度
intListLength_L（LinkList&L）
{
inti=0;
LinkListp=L;
if（p）p=p-next;
while（p）{
p=p->next;
i++;
}
returni;
}
2.15已知指针ha和hb分别指向两个单链表的头结点，并且已知两个链表的长度分别为m和n。
试写一算法将这两个链表连接在一起，假设指针hc指向连接后的链表的头结点，并要求算法以尽可能短的时间完成连接运算。
请分析你的算法的时间复杂度。
解：
voidMergeList_L（LinkList&ha,LinkList&hb,LinkList&hc）
{
LinkListpa,pb;
pa=ha;
pb=hb;
while（pa->next&&pb->next）{
pa=pa->next;
pb=pb->next;
}
if（!
pa->next）{
hc=hb;
while（pb->next）pb=pb->next;
pb->next=ha->next;
}
else{
hc=ha;
while（pa->next）pa=pa->next;
pa->next=hb->next;
}
}
2.16已知指针la和lb分别指向两个无头结点单链表中的首元结点。
下列算法是从表la中删除自第i个元素起共len个元素后，将它们插入到表lb中第i个元素之前。
试问此算法是否正确？
若有错，请改正之。
StatusDeleteAndInsertSub（LinkedListla,LinkedListlb,inti,intj,intlen）
{
if（i<0||j<0||len<0）returnINFEASIBLE;
p=la;k=1;
while（knext;k++;}
q=p;
while（k<=len）{q=q->next;k++;}
s=lb;k=1;
while（knext;k++;}
s->next=p;q->next=s->next;
returnOK;
}
解：
StatusDeleteAndInsertSub（LinkList&la,LinkList&lb,inti,intj,intlen）
{
LinkListp,q,s,prev=NULL;
intk=1;
if（i<0||j<0||len<0）returnINFEASIBLE;
//在la表中查找第i个结点
p=la;
while（p&&kprev=p;
p=p->next;
k++;
}
if（!
p）returnINFEASIBLE;
//在la表中查找第i+len-1个结点
q=p;k=1;
while（q&&kq=p->next;
k++;
}
if（!
q）returnINFEASIBLE;
//完成删除，注意，i=1的情况需要特殊处理
if（!
prev）la=q->next;
elseprev->next=q->next;
//将从la中删除的结点插入到lb中
if（j=1）{
q->next=lb;
lb=p;
}
else{
s=lb;k=1;
while（s&&ks=s->next;
k++;
}
if（!
s）returnINFEASIBLE;
q->next=s->next;
s->next=p;//完成插入
}
returnOK;
}
2.19已知线性表中的元素以值递增有序排列，并以单链表作存储结构。
试写一高效的算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素），同时释放被删结点空间，并分析你的算法的时间复杂度（注意，mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。
解：
StatusListDelete_L（LinkList&L,ElemTypemink,ElemTypemaxk）
{
LinkListp,q,prev=NULL;
if（mink>maxk）returnERROR;
p=L;
prev=p;
p=p->next;
while（p&&p->dataif（p->data<=mink）{
prev=p;
p=p->next;
}
else{
prev->next=p->next;
q=p;
p=p->next;
free（q）;
}
}
returnOK;
}
2.20同2.19题条件，试写一高效的算法，删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同），同时释放被删结点空间，并分析你的算法的时间复杂度。
解：
voidListDelete_LSameNode（LinkList&L）
{
LinkListp,q,prev;
p=L;
prev=p;
p=p->next;
while（p）{
prev=p;
p=p->next;
if（p&&p->data==prev->data）{
prev->next=p->next;
q=p;
p=p->next;
free（q）;
}
}
}
2.21试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表
逆置为
。
解：
//顺序表的逆置
StatusListOppose_Sq（SqList&L）
{
inti;
ElemTypex;
for（i=0;ix=L.elem[i];
L.elem[i]=L.elem[L.length-1-i];
L.elem[L.length-1-i]=x;
}
returnOK;
}
2.22试写一算法，对单链表实现就地逆置。
解：
//带头结点的单链表的逆置
StatusListOppose_L（LinkList&L）
{
LinkListp,q;
p=L;
p=p->next;
L->next=NULL;
while（p）{
q=p;
p=p->next;
q->next=L->next;
L->next=q;
}
returnOK;
}
第3章栈和队列
3.1若按教科书3.1.1节中图3.1（b）所示铁道进行车厢调度（注意：
两侧铁道均为单向行驶道），则请回答：
（1）如果进站的车厢序列为123，则可能得到的出站车厢序列是什么？
（2）如果进站的车厢序列为，则能否得到和的出站序列，并请说明为什么不能得到或者如何得到（即写出以‘S’表示进栈和以‘X’表示出栈的栈操作序列）。
解：
（1）123231321213132
（2）可以得到的出站序列，但不能得到的出站序列。
因为4356出站说明12已经在栈中，1不可能先于2出栈。
3.2简述栈和线性表的差别。
解：
线性表是具有相同特性的数据元素的一个有限序列。
栈是限定仅在表尾进行插入或删除操作的线性表。
3.3写出下列程序段的输出结果（栈的元素类型SElemType为char）。
voidmain（）
{
StackS;
charx,y;
InitStack（S）;
x=‘c’;y=‘k’;
Push（S,x）;Push（S,‘a’）;Push（S,y）;
Pop（S,x）;Push（S,‘t’）;Push（S,x）;
Pop（S,x）;Push（S,‘s’）;
while（!
StackEmpty（S））{Pop（S,y）;printf（y）;}
printf（x）;
}
解：
stack
3.4简述以下算法的功能（栈的元素类型SElemType为int）。
（1）statusalgo1（StackS）
{
inti,n,A[255];
n=0;
while（!
StackEmpty（S））{n++;Pop（S,A[n]）;}
for（i=1;i<=n;i++）Push（S,A[i]）;
}
（2）statusalgo2（StackS,inte）
{
StackT;intd;
InitStack（T）;
while（!
StackEmpty（S））{
Pop（S,d）;
if（d!
=e）Push（T,d）;
}
while（!
StackEmpty（T））{
Pop（T,d）;
Push（S,d）;
}
}
解：
（1）栈中的数据元素逆置
（2）如果栈中存在元素e，将其从栈中清除
3.11简述队列和堆栈这两种数据类型的相同点和差异处。
解：
栈是一种运算受限的线性表，其限制是仅允许在表的一端进行插入和删除运算。
队列也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。
6章树和二叉树
6.1已知一棵树边的集合为{,,,,,,,,,,}，请画出这棵树，并回答下列问题：
（1）哪个是根结点？
（2）哪些是叶子结点？
（3）哪个是结点G的双亲？
（4）哪些是结点G的祖先？
（5）哪些是结点G的孩子？
（6）哪些是结点E的子孙？
（7）那些是结点E的子孙？
（8）结点B和N的层次号分别是什么？
（9）树的深度是多少？
（10）以结点C为根的子树的深度是多少？
6.2一棵度为2的树与一棵二叉树有何区别？
解：
二叉树是颗有序树，但度为2的树则未必有序。
6.3试分别画出具有3个结点的树和3个结点的二叉树的所有不同形态。
6.4一棵深度为H的满k叉树有如下性质：
第H层上的结点都是叶子结点，其余各层上每个结点都有k棵非空子树。
如果按层次顺序从1开始对全部结点编号，问：
（1）各层的结点数目是多少？
（2）编号为p的结点的父结点（若存在）的编号是多少？
（3）编号为p的结点的第i个儿子结点（若存在）的编号是多少？
（4）编号为p的结点有右兄弟的条件是什么？
其右兄弟的编号是多少？
解：
（1）
（2）如果p是其双亲的最小的孩子（右孩子），则p减去根结点的一个结点，应是k的整数倍，该整数即为所在的组数，每一组为一棵满k叉树，正好应为双亲结点的编号。
如果p是其双亲的最大的孩子（左孩子），则p+k-1为其最小的弟弟，再减去一个根结点，除以k，即为其双亲结点的编号。
综合来说，对于p是左孩子的情况，i=（p+k-2）/k；对于p是右孩子的情况，i=（p-1）/k
如果左孩子的编号为p，则其右孩子编号必为p+k-1，所以，其双亲结点的编号为
向下取整，如1.5向下取整为1
（3）结点p的右孩子的编号为kp+1，左孩子的编号为kp+1-k+1=k（p-1）+2，第i个孩子的编号为k（p-1）+2+i-1=kp-k+i+1。
（4）当（p-1）%k!
=0时，结点p有右兄弟，其右兄弟的编号为p+1。
6.5已知一棵度为k的树中有
个度为1的结点，
个度为2的结点，…，
个度为k的结点，问该树中有多少个叶子结点？
解：
根据树的定义，在一颗树中，除树根结点外，每个结点有且仅有一个前驱结点，也就是说，每个结点与指向它的一个分支一一对应，所以除树根结点之外的结点树等于所有结点的分支数，即度数，从而可得树中的结点数等于所有结点的度数加1。
总结点数为
而度为0的结点数就应为总结点数减去度不为0的结点数的总和，即
6.6已知在一棵含有n个结点的树中，只有度为k的分支结点和度为0的叶子结点。
试求该树含有的叶子节点数目。
解：
利用上题结论易得结果。
设度为k的结点个数为
，则总结点数为
。
叶子结点的数目应等于总结点数减去度不为0的结点的数目，即
6.7一棵含有n个结点的k叉树，可能达到的最大深度和最小深度各为多少？
解：
能达到最大深度的树是单支树，其深度为n。
满k叉树的深度最小，其深度为
（证明见徐孝凯著数据结构实用教程P166）
6.8证明：
一棵满k叉树上的叶子结点数
和非叶子结点数
之间满足以下关系：
解：
一棵满k叉树的最后一层（深度为h）的结点数（叶子结点数）为
，其总结点数为
，则非叶子结点数
，从而得
6.9试分别推导含有n个结点和含
个叶子结点的完全三叉树的深度H。
解：
（1）根据完全三叉树的定义
（2）设总的结点数为n，非叶子结点数为
注意到每个非叶子结点的度均为3，则
由
6.10对于那些所有非叶子结点均含有左右子数的二叉树：
（1）试问：
有n个叶子结点的树中共有多少个结点？
（2）试证明：
，其中n为叶子结点的个数，
表示第i个叶子结点所在的层次（设根节点所在层次为1）。
解：
（1）总结点数为
，其中
为非叶子结点数，则叶子结点数为
，所以总结点数为
。
（2）用归纳法证明。
i=1，说明二叉树只有一个叶子结点，则整棵树只有一个根结点，
，结论成立。
设有n个叶子结点时也成立，即
，现假设增加一个叶子结点，这意味着在
升级会员 