数据结构C语言版第2版习题答案严蔚敏简化版.docx
《数据结构C语言版第2版习题答案严蔚敏简化版.docx》由会员分享，可在线阅读，更多相关《数据结构C语言版第2版习题答案严蔚敏简化版.docx（43页珍藏版）》请在冰点文库上搜索。
数据结构C语言版第2版习题答案严蔚敏简化版
第2章线性表
1．选择题
（1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（）。
A．110B．108C．100D．120
答案：
B
解释：
顺序表中的数据连续存储，所以第5个元素的地址为：
100+2*4=108。
（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
（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）将两个递增的有序链表合并为一个递增的有序链表。
要求结果链表仍使用原来两个链表的存储空间,不另外占用其它的存储空间。
表中不允许有重复的数据。
[算法描述]
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=pa?
pa:
pb;//插入剩余段
deleteLb;//释放Lb的头结点
}
（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;
第3章栈和队列
1．选择题
（1）若让元素1，2，3，4，5依次进栈，则出栈次序不可能出现在（）种情况。
A．5，4，3，2，1B．2，1，5，4，3C．4，3，1，2，5D．2，3，5，4，1
答案：
C
解释：
栈是后进先出的线性表，不难发现C选项中元素1比元素2先出栈，违背了栈的后进先出原则，所以不可能出现C选项所示的情况。
（2）若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为（）。
A．iB．n-iC．n-i+1D．不确定
答案：
C
解释：
栈是后进先出的线性表，一个栈的入栈序列是1，2，3，…，n，而输出序列的第一个元素为n，说明1，2，3，…，n一次性全部进栈，再进行输出，所以p1=n，p2=n-1，…，pi=n-i+1。
（3）数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素个数的公式为（）。
A．r-fB．（n+f-r）%nC．n+r-fD．（n+r-f）%n
答案：
D
解释：
对于非循环队列，尾指针和头指针的差值便是队列的长度，而对于循环队列，差值可能为负数，所以需要将差值加上MAXSIZE（本题为n），然后与MAXSIZE（本题为n）求余，即（n+r-f）%n。
（4）链式栈结点为：
（data,link），top指向栈顶.若想摘除栈顶结点，并将删除结点的值保存到x中,则应执行操作（）。
A．x=top->data;top=top->link；B．top=top->link;x=top->link；
C．x=top;top=top->link；D．x=top->link；
答案：
A
解释：
x=top->data将结点的值保存到x中，top=top->link栈顶指针指向栈顶下一结点，即摘除栈顶结点。
（5）设有一个递归算法如下
intfact（intn）{ //n大于等于0
if（n<=0）return1;
elsereturnn*fact（n-1）; }
则计算fact（n）需要调用该函数的次数为（）。
A． n+1 B． n-1 C．n D．n+2
答案：
A
解释：
特殊值法。
设n=0，易知仅调用一次fact（n）函数，故选A。
（6）栈在 （）中有所应用。
A．递归调用B．函数调用C．表达式求值D．前三个选项都有
答案：
D
解释：
递归调用、函数调用、表达式求值均用到了栈的后进先出性质。
（7）为解决计算机主机与打印机间速度不匹配问题，通常设一个打印数据缓冲区。
主机将要输出的数据依次写入该缓冲区，而打印机则依次从该缓冲区中取出数据。
该缓冲区的逻辑结构应该是（）。
A．队列B．栈C．线性表D．有序表
答案：
A
解释：
解决缓冲区问题应利用一种先进先出的线性表，而队列正是一种先进先出的线性表。
（8）设栈S和队列Q的初始状态为空，元素e1、e2、e3、e4、e5和e6依次进入栈S，一个元素出栈后即进入Q，若6个元素出队的序列是e2、e4、e3、e6、e5和e1，则栈S的容量至少应该是（ ）。
A．2B．3C．4D．6
答案：
B
解释：
元素出队的序列是e2、e4、e3、e6、e5和e1，可知元素入队的序列是e2、e4、e3、e6、e5和e1，即元素出栈的序列也是e2、e4、e3、e6、e5和e1，而元素e1、e2、e3、e4、e5和e6依次进入栈，易知栈S中最多同时存在3个元素，故栈S的容量至少为3。
（9）若一个栈以向量V[1..n]存储，初始栈顶指针top设为n+1，则元素x进栈的正确操作是（）。
A．top++;V[top]=x;B．V[top]=x;top++;
C．top--;V[top]=x;D．V[top]=x;top--;
答案：
C
解释：
初始栈顶指针top为n+1，说明元素从数组向量的高端地址进栈，又因为元素存储在向量空间V[1..n]中，所以进栈时top指针先下移变为n，之后将元素x存储在V[n]。
（10）设计一个判别表达式中左，右括号是否配对出现的算法，采用（ ）数据结构最佳。
A．线性表的顺序存储结构B．队列
C.线性表的链式存储结构D.栈
答案：
D
解释：
利用栈的后进先出原则。
（11）用链接方式存储的队列，在进行删除运算时（ ）。
A.仅修改头指针B.仅修改尾指针
C.头、尾指针都要修改D.头、尾指针可能都要修改
答案：
D
解释：
一般情况下只修改头指针，但是，当删除的是队列中最后一个元素时，队尾指针也丢失了，因此需对队尾指针重新赋值。
（12）循环队列存储在数组A[0..m]中，则入队时的操作为（ ）。
A.rear=rear+1B.rear=（rear+1）%（m-1）
C.rear=（rear+1）%mD.rear=（rear+1）%（m+1）
答案：
D
解释：
数组A[0..m]中共含有m+1个元素，故在求模运算时应除以m+1。
（13）最大容量为n的循环队列，队尾指针是rear，队头是front，则队空的条件是（ ）。
A.（rear+1）%n==frontB.rear==front
C．rear+1==frontD.（rear-l）%n==front
答案：
B
解释：
最大容量为n的循环队列，队满条件是（rear+1）%n==front，队空条件是rear==front。
（14）栈和队列的共同点是（ ）。
A.都是先进先出B.都是先进后出
C.只允许在端点处插入和删除元素D.没有共同点
答案：
C
解释：
栈只允许在栈顶处进行插入和删除元素，队列只允许在队尾插入元素和在队头删除元素。
（15）一个递归算法必须包括（ ）。
A.递归部分B.终止条件和递归部分
C.迭代部分D.终止条件和迭代部分
答案：
B
2．算法设计题
（1）将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。
当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m时该栈为空。
两个栈均从两端向中间增长。
试编写双栈初始化，判断栈空、栈满、进栈和出栈等算法的函数。
双栈数据结构的定义如下：
Typedefstruct
{inttop[2],bot[2];//栈顶和栈底指针
SElemType*V;//栈数组
intm;//栈最大可容纳元素个数
}DblStack
[题目分析]
两栈共享向量空间，将两栈栈底设在向量两端，初始时，左栈顶指针为-1，右栈顶为m。
两栈顶指针相邻时为栈满。
两栈顶相向、迎面增长，栈顶指针指向栈顶元素。
[算法描述]
（1） 栈初始化
int Init（）
{S.top[0]=-1;
S.top[1]=m;
return 1; //初始化成功
}
（2） 入栈操作：
int push（stkS ,int i,int x）
∥i为栈号，i=0表示左栈，i=1为右栈，x是入栈元素。
入栈成功返回1，失败返回0
{if（i<0||i>1）{cout<<“栈号输入不对”<if（S.top[1]-S.top[0]==1）{cout<<“栈已满”<switch（i）
{case 0:
S.V[++S.top[0]]=x; return
（1）; break;
case 1:
S.V[--S.top[1]]=x; return
（1）;
}
}∥push
（3） 退栈操作
ElemTypepop（stkS,int i）
∥退栈。
i代表栈号，i=0时为左栈，i=1时为右栈。
退栈成功时返回退栈元素
∥否则返回-1
{if（i<0||i>1）{cout<<“栈号输入错误”< switch（i）
{case 0:
if（S.top[0]==-1）{cout<<“栈空”<else return（S.V[S.top[0]--]）;
case 1:
if（S.top[1]==m{cout<<“栈空”<else return（S.V[S.top[1]++]）;
}∥switch
}∥算法结束
（4） 判断栈空
int Empty（）;
{return （S.top[0]==-1&&S.top[1]==m）;
}
[算法讨论]
请注意算法中两栈入栈和退栈时的栈顶指针的计算。
左栈是通常意义下的栈，而右栈入栈操作时，其栈顶指针左移（减1），退栈时，栈顶指针右移（加1）。
（2）回文是指正读反读均相同的字符序列，如“abba”和“abdba”均是回文，但“good”不是回文。
试写一个算法判定给定的字符向量是否为回文。
（提示：
将一半字符入栈）
[题目分析]
将字符串前一半入栈，然后，栈中元素和字符串后一半进行比较。
即将第一个出栈元素和后一半串中第一个字符比较，若相等，则再出栈一个元素与后一个字符比较，……，直至栈空，结论为字符序列是回文。
在出栈元素与串中字符比较不等时，结论字符序列不是回文。
[算法描述]
#defineStackSize100//假定预分配的栈空间最多为100个元素
typedefcharDataType;//假定栈元素的数据类型为字符
typedefstruct
{DataTypedata[StackSize];
inttop;
}SeqStack;
intIsHuiwen（char*t）
{//判断t字符向量是否为回文，若是，返回1，否则返回0
SeqStacks;
inti,len;
chartemp;
InitStack（&s）;
len=strlen（t）;//求向量长度
for（i=0;iPush（&s,t[i]）;
while（!
EmptyStack（&s））
{//每弹出一个字符与相应字符比较
temp=Pop（&s）;
if（temp!
=S[i]） return0;//不等则返回0
elsei++;
}
return1;//比较完毕均相等则返回1
}
（3）设从键盘输入一整数的序列：
a1,a2,a3，…，an，试编写算法实现：
用栈结构存储输入的整数，当ai≠-1时，将ai进栈；当ai=-1时，输出栈顶整数并出栈。
算法应对异常情况（入栈满等）给出相应的信息。
[算法描述]
#definemaxsize栈空间容量
voidInOutS（ints[maxsize]）
//s是元素为整数的栈，本算法进行入栈和退栈操作。
{inttop=0;//top为栈顶指针，定义top=0时为栈空。
for（i=1;i<=n;i++）//n个整数序列作处理。
{cin>>x）;//从键盘读入整数序列。
if（x!
=-1）//读入的整数不等于-1时入栈。
｛if（top==maxsize-1）{cout<<“栈满”<elses[++top]=x;//x入栈。
｝
else//读入的整数等于-1时退栈。
{if（top==0）{cout<<“栈空”<elsecout<<“出栈元素是”<}
}//算法结束。
（6）假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素站点（注意不设头指针），试编写相应的置空队、判队空、入队和出队等算法。
[算法描述]
//先定义链队结构:
typedefstructqueuenode
{Datatypedata;
structqueuenode*next;
}QueueNode;//以上是结点类型的定义
typedefstruct
{queuenode*rear;
}LinkQueue;//只设一个指向队尾元素的指针
（1）置空队
voidInitQueue（LinkQueue*Q）
{//置空队：
就是使头结点成为队尾元素
QueueNode*s;
Q->rear=Q->rear->next;//将队尾指针指向头结点
while（Q->rear!
=Q->rear->next）//当队列非空，将队中元素逐个出队
{s=Q->rear->next;
Q->rear->next=s->next;
deletes;
}//回收结点空间
}
（2）判队空
intEmptyQueue（LinkQueue*Q）
{//判队空。
当头结点的next指针指向自己时为空队
returnQ->rear->next->next==Q->rear->next;
}
（3）入队
voidEnQueue（LinkQueue*Q,Datatypex）
{//入队。
也就是在尾结点处插入元素
QueueNode*p=newQueueNode;//申请新结点
p->data=x;p->next=Q->rear->next;//初始化新结点并链入
Q-rear->next=p;
Q->rear=p;//将尾指针移至新结点
}
（4）出队
DatatypeDeQueue（LinkQueue*Q）
{//出队,把头结点之后的元素摘下
Datatypet;
QueueNode*p;
if（EmptyQueue（Q））
Error（"Queueunderflow"）;
p=Q->rear->next->next;//p指向将要摘下的结点
x=p->data;//保存结点中数据
if（p==Q->rear）
{//当队列中只有一个结点时，p结点出队后，要将队尾指针指向头结点
Q->rear=Q->rear->next;
Q->rear->next=p->next;
}
else
Q->rear->next->next=p->next;//摘下结点p
deletep;//释放被删结点
returnx;
}
第4章串、数组和广义表
1．选择题
（1）串是一种特殊的线性表，其特殊性体现在（）。
A．可以顺序存储B．数据元素是一个字符
C．可以链式存储D．数据元素可以是多个字符若
答案：
B
（2）串下面关于串的的叙述中，（）是不正确的？
A．串是字符的有限序列B．空串是由空格构成的串
C．模式匹配是串的一种重要运算D．串既可以采用顺序存储，也可以采用链式存储
答案：
B
解释：
空格常常是串的字符集合中的一个元素，有一个或多个空格组成的串成为空格串，零个字符的串成为空串，其长度为零。
（3）串“ababaaababaa”的next数组为（）。
A．012345678999B．012121111212C．011234223456D．0123012322345
答案：
C
（4）串“ababaabab”的nextval为（）。
A．010104101B．010102101C．010100011D．010101011
答案：
A
（5）串的长度是指（）。
A．串中所含不同字母的个数B．串中所含字符的个数
C．串中所含不同字符的个数D．串中所含非空格字符的个数
答案：
B
解释：
串中字符的数目称为串的长度。
（6）假设以行序为主序存储二维数组A=array[1..100,1..100]，设每个数据元素占2个存储单元，基地址为10，则LOC[5,5]=（）。
A．808B．818C．1010D．1020
答案：
B
解释：
以行序为主，则LOC[5,5]=[（5-1）*100+（5-1）]*2+10=818。
（7）设有数组A[i,j]，数组的每个元素长度为3字节，i的值为1到8，j的值为1到10，数组从内存首地址BA开始顺序存放，当用以列为主存放时，元素A[5,8]的存储首
升级会员 