李云清版数据结构答案.docx
《李云清版数据结构答案.docx》由会员分享，可在线阅读，更多相关《李云清版数据结构答案.docx（90页珍藏版）》请在冰豆网上搜索。
1
数据结构
（C语言版）（第2版）
习题解析
揭安全李云清杨庆红
江西师范大学计算机信息工程学院
联系方式：
janquan@
（习题答案仅供参考）
2
第1章绪论
1.1什么是数据结构？
【答】：
数据结构是指按一定的逻辑结构组成的一批数据，使用某种存储结构将这批数据存储
于计算机中，并在这些数据上定义了一个运算集合。
1.2数据结构涉及哪几个方面？
【答】：
数据结构涉及三个方面的内容，即数据的逻辑结构、数据的存储结构和数据的运算集
合。
1.3两个数据结构的逻辑结构和存储结构都相同，但是它们的运算集合中有一个运算的定义不
一样，它们是否可以认作是同一个数据结构？
为什么？
【答】：
不能，运算集合是数据结构的重要组成部分，不同的运算集合所确定的数据结构是不
一样的，例如，栈与队列它们的逻辑结构与存储结构可以相同，但由于它们的运算集合不一样，
所以它们是两种不同的数据结构。
1.4线性结构的特点是什么？
非线性结构的特点是什么？
【答】：
线性结构元素之间的关系是一对一的，在线性结构中只有一个开始结点和一个终端结
点，其他的每一个结点有且仅有一个前驱和一个后继结点。
而非线性结构则没有这个特点，元
素之间的关系可以是一对多的或多对多的。
1.5数据结构的存储方式有哪几种？
【答】：
数据结构的存储方式有顺序存储、链式存储、散列存储和索引存储等四种方式。
1.6算法有哪些特点？
它和程序的主要区别是什么？
【答】：
算法具有
（1）有穷性
（2）确定性（3）0个或多个输入（4）1个或多个输出（5）可
行性等特征。
程序是算法的一种描述方式，通过程序可以在计算机上实现算法。
1.7抽象数据类型的是什么？
它有什么特点？
【答】：
抽象数据类型是数据类型的进一步抽象，是大家熟知的基本数据类型的延伸和发展。
抽象数据类型是与表示无关的数据类型，是一个数据模型及定义在该模型上的一组运算。
对一
个抽象数据类型进行定义时，必须给出它的名字及各运算的运算符名，即函数名，并且规定这
些函数的参数性质。
一旦定义了一个抽象数据类型及具体实现，程序设计中就可以像使用基本
数据类型那样，十分方便地使用抽象数据类型。
抽象数据类型的设计者根据这些描述给出操作
的具体实现，抽象数据类型的使用者依据这些描述使用抽象数据类型。
1.8算法的时间复杂度指的是什么？
如何表示？
【答】：
算法执行时间的度量不是采用算法执行的绝对时间来计算的，因为一个算法在不同的
机器上执行所花的时间不一样，在不同时刻也会由于计算机资源占用情况的不同，使得算法在
同一台计算机上执行的时间也不一样，另外，算法执行的时间还与输入数据的状态有关，所以
对于算法的时间复杂性，采用算法执行过程中其基本操作的执行次数，称为计算量来度量。
算
法中基本操作的执行次数一般是与问题规模有关的，对于结点个数为n的数据处理问题，用
T（n）表示算法基本操作的执行次数。
为了评价算法的执行效率，通常采用大写O符号表示算法
的时间复杂度，大写O符号给出了函数f的一个上限。
其它义如下：
3
定义：
f（n）=O（g（n））当且仅当存在正的常数c和n0，使得对于所有的n≥n0，有f（n）≤cg（n）。
上述定义表明，函数f顶多是函数g的c倍，除非n小于n0。
因此对于足够大的n（如n≥n0），
g是f的一个上限（不考虑常数因子c）。
在为函数f提供一个上限函数g时，通常使用比较
简单的函数形式。
比较典型的形式是含有n的单个项（带一个常数系数）。
表1-1列出了一些
常用的g函数及其名称。
对于表1-1中的对数函数logn，没有给出对数基，原因是对于任何大
于1的常数a和b都有logan=logbn/logba,所以logan和logbn都有一个相对的乘法系数1/logba，
其中a是一个常量。
表1-1常用的渐进函数
1.9算法的空间复杂度指的是什么？
如何表示？
【答】：
算法的空间复杂度是指算法在执行过程中占用的额外的辅助空间的个数。
可以将它表
示为问题规模的函数，并通过大写O符号表示空间复杂度。
1.10对于下面的程序段，分析带下划线的语句的执行次数，并给出它们的时间复杂度T（n）。
（1）i++;
（2）for（i=0;iif（a[i]（3）for（i=0;ifor（j=0;jprintf（“%d”,i+j）;
（4）for（i=1;i<=n-1;i++）
{k=i;
for（j=i+1;j<=n;j++）
if（a[j]>a[j+1]）k=j;
t=a[k];a[k]=a[i];a[i]=t;
}
（5）for（i=0;ifor（j=0;j{++x;s=s+x;}
【答】：
（1）O
（1）；
（2）O（n）；（3）O（n2）；（4）O（n）；（5）O（n2）
4
第2章线性表及其顺序存储
2.1选择题
（1）表长为n的顺序存储的线性表，当在任何位置上插入或删除一个元素的概率相等时，
插入一个元素所需移动元素的平均个数为（E），删除一个元素所需移动元素的平均个数
为（A）。
A．（n−1）/2B．nC．n+1D．n−1
E．n/2F．（n+1）/2G．（n−2）/2
（2）设栈S和队列Q的初始状态为空，元素e1、e2、e3、e4、__________e5和e6依次通过栈S，
一个元素出栈后即进入队列Q，若6个元素出队的序列为e2、e4、e3、e6、e5和e1，则栈S
的容量至少应该为（C）。
A．6B．4C．3D．2
（3）设栈的输入序列为1、2、3…n，若输出序列的第一个元素为n，则第i个输出的元素为
（B）。
A．不确定B．n−i+1C．iD．n−i
（4）在一个长度为n的顺序表中删除第i个元素（1<=i<=n）时，需向前移动（A）个
元素。
A．n−iB．n−i+1C．n−i−1D．i
（5）若长度为n的线性表采用顺序存储结构存储，在第i个位置上插入一个新元素的时
间复杂度为（A）。
A．O（n）B．O
（1）C．O（n2）D．O（n3）
（6）表达式a*（b+c）−d的后缀表达式是（B）。
A．abcd*+−B．abc+*d−C．abc*+d−D．−+*abcd
（7）队列是一种特殊的线性表，其特殊性在于（C）。
A．插入和删除在表的不同位置执行B．插入和删除在表的两端位置执行
C．插入和删除分别在表的两端执行D．插入和删除都在表的某一端执行
（8）栈是一种特殊的线性表，具有（B）性质。
A．先进先出B．先进后出C．后进后出D．顺序进出
（9）顺序循环队列中（数组的大小为n），队头指示front指向队列的第1个元素，队尾
指示rear指向队列最后元素的后1个位置，则循环队列中存放了n−1个元素，即循环队列满
的条件为（B）。
A．（rear+1）%n=front−1B．（rear+1）%n=front
C．（rear）%n=frontD．rear+1=front
（10）顺序循环队列中（数组的大小为6），队头指示front和队尾指示rear的值分别为3
和0，当从队列中删除1个元素，再插入2个元素后，front和rear的值分别为（D）。
A．5和1B．2和4C．1和5D．4和2
2.2什么是顺序表？
什么是栈？
什么是队列？
5
【答】：
当线性表采用顺序存储结构时，即为顺序表。
栈是一种特殊的线性表，它的特殊性表
现在约定了在这种线性表中数据的插入与删除操作只能在这种线性表的同一端进行（即栈顶），
因此，栈具有先进后出、后进先出的特点。
队列也是一种特殊的线性表，它的特殊性表现在约
定了在这种线性表中数据的插入在表的一端进行，数据的删除在表的另一端进行，因此队列具
有先进先出，后进后出的特点。
2.3设计一个算法，求顺序表中值为x的结点的个数。
【答】：
顺序表的存储结构定义如下（文件名seqlist.h）：
#include
#defineN100/*预定义最大的数据域空间*/
typedefintdatatype;/*假设数据类型为整型*/
typedefstruct{
datatypedata[N];/*此处假设数据元素只包含一个整型的关键字域*/
intlength;/*线性表长度*/
}seqlist;/*预定义的顺序表类型*/
算法countx（L,x）用于求顺序表L中值为x的结点的个数。
intcountx（seqlist*L,datatypex）
{intc=0;
inti;
for（i=0;ilength;i++）
if（L->data[i]==x）c++;
returnc;
}
2.4设计一个算法，将一个顺序表倒置。
即，如果顺序表各个结点值存储在一维数组a中，倒
置的结果是使得数组a中的a[0]等于原来的最后一个元素，a[1]等于原来的倒数第2个元
素，…，a的最后一个元素等于原来的第一个元素。
【答】：
顺序表的存储结构定义同题2.3，实现顺序表倒置的算法程序如下：
voidverge（seqlist*L）
{intt,i,j;
i=0;
j=L->length-1;
while（i{t=L->data[i];
L->data[i++]=L->data[j];
L->data[j--]=t;
}
}
2.5已知一个顺序表中的各结点值是从小到大有序的，设计一个算法，插入一个值为x的结点，
使顺序表中的结点仍然是从小到大有序。
【答】：
顺序表的定义同题2.3，实现本题要求的算法程序如下：
6
voidinsertx（seqlist*L,datatypex）
{intj;
if（L->length{j=L->length-1;
while（j>=0&&L->data[j]>x）
{L->data[j+1]=L->data[j];
j--;
}
L->data[j+1]=x;
L->length++;
}
}
2.6将下列中缀表达式转换为等价的后缀表达式。
（1）5+6*7
（2）（5-6）/7
（3）5-6*7*8
（4）5*7-8
（5）5*（7-6）+8/9
（6）7*（5-6*8）-9
【答】：
（7）5+6*7后缀表达式：
567*+
（8）（5-6）/7后缀表达式：
56-7/
（9）5-6*7*8后缀表达式：
567*8*-
（10）5*7-8后缀表达式：
57*8-
（11）5*（7-6）+8/9后缀表达式：
576-*89/+
（12）7*（5-6*8）-9后缀表达式：
7568*-*9-
2.7循环队列存储在一个数组中，数组大小为n，队首指针和队尾指针分别为front和rear，请
写出求循环队列中当前结点个数的表达式。
【答】：
循环队列中当前结点个数的计算公式是：
（n+rear-front）%n
2.8编号为1,2,3,4的四列火车通过一个栈式的列车调度站，可能得到的调度结果有哪些？
如果
有n列火车通过调度站，请设计一个算法，输出所有可能的调度结果。
【答】：
解题思路：
栈具有先进后出、后进先出的特点，因此，任何一个调度结果应该是1，2，3，4
全排列中的一个元素。
由于进栈的顺序是由小到大的，所以出栈序列应该满足以下条件：
对于
序列中的任何一个数其后面所有比它小的数应该是倒序的，例如4321是一个有效的出栈序列，
1423不是一个有效的出栈结果（4后面比它小的两个数2，3不是倒序）。
据此，本题可以通过
算法产生n个数的全排列，然后将满足出栈规则的序列输出。
产生n个数的全排列有递归与非递归两种实现算法。
产生全排列的递归算法：
7
设R={r1,r2,…,rn}是要进行排列的n个元素，Ri=R-{ri}。
集合X中元素的全排列记为
perm（X）。
（ri）perm（X）表示在全排列perm（X）的每一个排列前加上前缀ri得到的排列。
R的全排
列可归纳定义如下：
当n=1时，perm（R）=（r），其中r是集合R中惟一的元素；
当n>1时，perm（R）由（r1）perm（R1）,（r2）perm（R2）,…,（rn）perm（Rn）构成。
依此递归定义，可设计产生perm（R）的递归算法如下：
递归解法：
（2_8_1.c）
#include
intcont=1;/*全局变量，用于记录所有可能的出栈序列个数*/
voidprint（intstr[],intn）;
/*求整数序列str[]从k到n的全排列*/
voidperm（intstr[],intk,intn）
{inti,temp;
if（k==n-1）print（str,n）;
else
{for（i=k;i{temp=str[k];str[k]=str[i];str[i]=temp;
perm（str,k+1,n）;/*递归调用*/
temp=str[i];str[i]=str[k];str[k]=temp;
}
}
}
/*本函数判断整数序列str[]是否满足进出栈规则,若满足则输出*/
voidprint（intstr[],intn）
{inti,j,k,l,m,flag=1,b[2];
for（i=0;i{m=0;
for（j=i+1;jif（str[i]>str[j]）{if（m==0）b[m++]=str[j];
else{if（str[j]>b[0]）{flag=0;}
elseb[0]=str[j];
}
}
}
if（flag）/*满足出栈规则则输出str[]中的序列*/
{printf（"%2d:
",cont++）;
for（i=0;iprintf（"%d",str[i]）;
printf（"\n"）;
8
}
}
intmain（）
{intstr[100],n,i;
printf（"inputaint:
"）;/*输出排列的元素个数*/
scanf（"%d",&n）;
for（i=0;istr[i]=i+1;
printf（"inputtheresult:
\n"）;
perm（str,0,n）;
printf（"\n"）;
return0;
}
当参与进出栈的元素个数为4时，输出的结果如下图所示。
该算法执行的时间复杂度为O（n!
）。
随着n的增大，算法的执行效率非常的低。
非递归解法：
（2_7_8.c）
对一组数穷尽所有排列，还可一种更直接的方法，将一个排列看作一个长整数，则所有排
列对应着一组整数，将这组整数按从小到大的顺序排成一个数列，从对应最小的整数开始，按
数列的递增顺序逐一列举每个排列对应的每一个整数，这能更有效地完成排列的穷举。
从一个
排列找出对应数列的下一个排列可在当前排列的基础上作部分调整来实现。
倘若当前排列为
1,2,4,6,5,3，并令其对应的长整数为124653。
要寻找比长整数124653更大的排列，可从该排列
的最后一个数字顺序向前逐位考察，当发现排列中的某个数字比它前一个数字大时，如本例中
的6比它的前一位数字4大，则说明还有可能对应更大整数的排列。
但为顺序从小到大列举出
所有的排列，不能立即调整得太大，如本例中将数字6与数字4交换得到的排列为126453就
不是排列124653的下一个排列。
为得到排列124653的下一个排列，应从已考察过的那部分数
字中选出比数字4大，但又是它们中最小的那一个数字，比如数字5，与数字4交换。
该数字
也是从后向前考察过程中第一个比4大的数字，5与4交换后，得到排列125643。
在前面数字
1，2，5固定的情况下，还应选择对应最小整数的那个排列，为此还需将后面那部分数字的排
列颠倒，如将数字6，4，3的排列顺序颠倒，得到排列1,2,5,3,4,6，这才是排列1，2，4，6，
9
5，3的下一个排列。
按照以上想法可以编写非递归程序实现n个数的全排列，对满足进出栈
规则的排列则计数并输出。
/*本程序输出12...n个序列进栈出栈的序列*/
#include
intpl（intn）
{inta[100];/*最大处理范围为99个数*/
intflag=1,flag1=0;
FILE*rf;
inti,j,k,x,count=0;
rf=fopen（"stack.txt","w"）;/*pl.txt用于存放进出栈序列结果*/
for（i=1;i<=n;i++）/*初始序列*/
a[i]=i;
while（flag）/*还剩余未输出的排列*/
{flag1=1;/*判断本次排列是否符合进栈出栈序列*/
for（i=1;i<=n;i++）
{j=i+1;
while（j<=n&&a[j]>a[i]）j++;/*找a[i]后第一个比a[i]小__________的元素a[j]*/
k=j+1;
while（k<=n）/*如果a[j]后还有比a[i]小且比a[j]大的元素,则此排列无效*/
{if（a[k]a[j]）flag1=0;
k++;
}
}
if（flag1）
{for（i=1;i<=n;i++）/*输出当前排列*/
{printf（"%4d",a[i]）;fprintf（rf,"%4d",a[i]）;}
printf（"\n"）;fprintf（rf,"\n"）;
count++;/*计数器加1*/
}
i=n;/*从后向前找相邻位置后大前小的元素值*/
while（i>1&&a[i]if（i==1）flag=0;/*未找到则结束*/
else
{j=i-1;i=n;/*若找到,则在该位置的后面从右向左找第一个比该元素大的值*/
while（i>j&&a[i]k=a[j];/*交换两元素的值*/
a[j]=a[i];
a[i]=k;
k=j+1;/*对交换后后面的数据由小到大排序*/
10
for（i=k+1;i<=n;i++）/*插入排序*/
{j=i-1;
x=a[i];
while（j>=k&&xa[j+1]=x;
}
}
}
fclose（rf）;
returncount;/*返回排列总个数*/
}
voidmain（）
{intn,m=0;
printf（"pleaseinputn:
"）;/*输入排列规模*/
scanf（"%d",&n）;
m=pl（n）;
printf（"\nm=%d",m）;/*输出满足进出栈的排列总个数*/
}
程序运行时如果输入4，则输出的结果如下图所示。
该算法的时间复杂度也是O（n!
）。
结论：
如果n个数按编号由小到大的顺序进栈，进栈的过程中可以出栈，则所有可能的出栈序
列的总数为：
（1）!
!
（2）!
nnn
n
+
11
第3章线性表的链式存储
3.1选择题
（1）两个有序线性表分别具有n个元素与m个元素且n≤m，现将其归并成一个有序表，
其最少的比较次数是（A）。
A．nB．mC．n−1D．m+n
（2）非空的循环单链表head的尾结点（由p所指向）满足（C）。
A．p->next==NULLB．p==NULLC．p->next==headD．p==head
（3）在带头结点的单链表中查找x应选择的程序体是（C）。
A．node*p=head->next;while（p&&p->info!
=x）p=p->next;
if（p->info==x）returnpelsereturnNULL;
B．node*p=head;while（p&&p->info!
=x）p=p->next;returnp;
C．node*p=head->next;while（p&&p->info!
=x）p=p->next;returnp;
D．node*p=head;while（p->info!
=x）p=p->next;returnp;
（4）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（D）。
A．必须是连续的B．部分地址必须是连续的
C．一定是不连续的D．连续不连续都可以
（5）在一个具有n个结点的有序单链表中插入一个新结点并保持单链表仍然有序的时间
复杂度是（B）。
A．O
（1）B．O（n）C．O（n2）D．O（nlog2
n）
（6）用不带头结点的单链表存储队列时，其队头指针指向队头结点，其队尾指针指向队
尾结点，则在进行删除操作时（D）。
A．仅修改队头指针B．仅修改队尾指针
C．队头、队尾指针都要修改D．队头,队尾指针都可能要修改
（7）若从键盘输入n个元素，则建立一个有序单向链表的时间复杂度为（B）。
A．O（n）B．O（n2）C．O（n3）D．O（n?
log2n）
（8）下面哪个术语与数据的存储结构无关（D）。
A．顺序表B．链表C．散列表D．队列
（9）在一个单链表中，若删除p所指结点的后续结点，则执行（A）。
A．p->next=p->next->next;B．p=p->next;p->next=p->next->next;
C．p->next=p->next;D．p=p->next->next;
（10）在一个单链表中，若p所指结点不是最后结点，在p之后插入s所指结点，则执行（B）。
A．s->next=p;p->next=s;B．s->next=p->next;p->next=s;
C．s->next=p->next;p=s;D．p->next=s;s->next=p;
3.2设计一个算法，求一个单链表中的结点个数。
【答】：
单链表存储结构定义如下（相关文件：
linklist.h）
#include
12
#include
typedefstructnode
{intdata;
structnode*next;
}linknode;
typedeflinknode*linklist;
/*
升级会员 