计算机软件技术基础所有题目答案自学.doc

数据结构习题答

案第一节概论

第二节线性

表

第三节栈和队列15 第五节树18 第七节查找24 第八节排序28

31 操作系统练习题参考答

案

数据结构习题答案

第一节 概 论

一、 选择题 1．要求同一逻辑结构的所有数据元素具有相同的特性，这意味着 A.数据元素具有同一的特点 ~B.不仅数据元素包含的数据项的个数要相同，而且对应数据项 的类型要一致 C ．每个数据元素都一样 D ．数据元素所包含的数据项的个数要相等 2．数据结构是一门研究非数值计算的程序设计问题中计算机的 ( (1) ) 以及它们之间的 ( (2) ) 和 运算的学科。

(1) ~A.操作对象 B .计算方法 C .逻辑存储 D ⑵A .结构 ~B.关系 C .运算 D .算法

3. 数据结构被形式地定义为(D , R),其中D 是((1)) 合。 (1) A .算法 ~B.数据元素 C .数据操作 D ⑵A .操作 B .映像 C .存储 ~D.关系

10. 根据数据元素之间关系的不同特性，以下四类基本的逻辑结构反映了四类基本的数据组织形 式，其中解释错误的是 ( ) 。

~A.集合中任何两个结点之间都有逻辑关系但组织形式松散 B .线性结构中结点按逻辑关系依 次排列形成一条“锁链” C .树形结构具有分支、层次特性，其形态有点像自然界中的树 D.图状结构中的各个结点按逻辑关系互相缠绕，任何两个结点都可以邻接 11. 以下说法正确的是 ( ) 。 A.数据元素是数据的最小单位 数据项的集合 ~D ?数据结构是带有结构的数据元素的集合 二、 判断题

X1.数据元素是数据的最小单位。

．数据映像 的有限集合，R 是D 上((2))的有限集 ．逻辑结构 4．在数据结构中，从逻辑上可以把数据结构分为 ( ) 。

A.动态结构和静态结构 B .紧凑结构和非紧凑结构 ~C ?线性结构和非线性结构 D .内部结构 和外部结构 5．线性表的顺序存储结构是一种 ~A.随机存取 B .顺序存取 6．算法分析的目的是 ( ) 。

A.找出数据结构的合理性 B

D.分析算法的易懂性和文档性 7．计算机算法指的是 ( (1) ) ， ( ) 的存储结构。 C ．索引存取 D ． Hash 存取

.研究算法中的输入和输出的关系

~C .分析算法的效率以求改进

(1) A .计算方法 B .排序方法

(2) A .可行性、可移植性和可扩充性 定性 D .易读性、稳定性和安全性

8. 线性表若采用链表存储结构，要求内存中可用存储单元的地址

A.必须是连续的 B .部分必须是连续的

9. 在以下的叙述中，正确的是 ( ) 。

A.线性表的线性存储结构优于链式存储结构 的线性表 C .栈的操

作方式是先进先出

它必须具备输入、输出和 ( (2) ) 等五个特征。

-C ?解决某一问题的有限运算序列 D .调度方法 ~B.可行性、确定性和有穷性 C .确定性，有穷性和稳 ( ) 。 C .一定是不连续的 ~D ?连续不连续都可以 ~B.二维数组是它的每个数据元素为一个线性表 D ．队列的操作方式是先进后出 B ．数据项是数据的基本单位 C ．数据结构是带有结构的各

14. 通常从___确定性___、__可读性_、___健壮性__、_高效性__等几方面评价算法 (包括程序)的 质

量。

15. 一个算法的时空性能是指该算法的 _时间复杂度和 ___空间复杂度 _，前者是算法包含的 __计算 量__，后者是算法需要的 ___存储量 __。

16. 在一般情况下，一个算法的时间复杂度是 __问题规模 __的函数。

17. 常见时间复杂度的量级有：常数阶 O(__1_)、对数阶 O(__log 2n___)、线性阶 O(__n__)、平方 阶0(_n 2_)和指数阶0(_2_)。通常认为，具有指数阶量级的算法是 — 不可行—的。 18. 数据结构的基本任务是数据结构的 __设计__和__实现__。 19. 数据对象是性质相同的 __数据元素 _的集合。

20. 抽象数据类型是指一个 __数学模型 __以及定义在该模型上的一组操作。 四、应用题 1. 分析下列程序段的时间复杂度。

i=1 ；

WHILE (i<=n) i=i

~2；

答： O(log2n)

V 2. V 3. X 4. V5.

V6.数据的物理结构是数据在计算机中实际的存储形式。 数据结构是带有结构的数据元素的集合。 数据结构、数据元素、数据项在计算机中的映像分别称为存储结构、结点、数据域。 数据项是数据的基本单位。

数据的逻辑结构是指各数据元素之间的逻辑关系，是用户按使用需要建立的。 X7.算法和程序没有区别，所以在数据结构中二者是通用的。 X 8.顺序存储结构属于静态结构，链式存储结构属于动态结构。

三、填空题

1.所谓数据的逻辑结构指的是数据元素之间的 _______ 逻辑关系 ____ 。

2，数据结构是相互之间存在一种或多种特定关系的数据元素的集合，它包括三方面的内容 据的逻辑结构、数据的存储结构、对数据施加的操作 ___。 3. ________________________ 数据的逻辑结构包括 集合结构___、 线性结构 构 _____ 四种类型。

树型结构 和__图状结 4. 在线性结构中，开始结点 __没有_前驱结点，其余每个结点有且只有 __一个_个前驱结点。 5. 在树形结构中，根结点只有 ___一个___，其余每个结点有且只有 ___一个___前驱结点；叶结点 没有—后继—结点，其余每个结点的后继结点可以有 — 任意个__?

6. 在图形结构中，每个结点的前驱结点和后继结点可以有 ___任意个

7. 算法的五个重要特性是 __可行性___、 ___确定性 ___、___有穷性 一个 输入 输出

8. 下列程序段的时间复杂度是 for (i=1 ；i<=n ；i++) 9. 下列程序段的时间复杂度是 S=0 ；

for(i=1 ；i<=n ；i++)

for(j=1 ；j<=n ；j++) sum=s ；

10. 存储结构是逻辑结构的 _ __O (n )___。 A[i ， i]=0 ； __ O ( n2)___。 s=s+B[i,j] 物理__实现。

11. 从数据结构的观点看，通常所说的“数据”应分成三个不同的层次，即

素_和__数据项 ___。

12. 根据需要，数据元素又被称为 __结点 __

13. 通常，存储结点之间可以有 ___顺序存储 储_四种关联方式，称为四种基本存储方式。 数据 数据元

记录 __、 ___元素__或__顶点 _。 ____ 链式存储 __、 __ 索引存储 散列存

2. 叙述算法的定义及其重要特性。

答：算法是对特定问题求解步骤的一种描述，是指令的有限序列。其中每一条指令表示一个或多 个操作。算法应该具有下列特性：可行性、确定性、有穷性、输入和输出。 3. 简述下列术语：数据，数据元素，数据结构，数据对象。

答：数据是信息的载体，是描述客观事物的数、字符，以及所有能输入到计算机中并被计算机程 序识别和处理的符号的集合。数据元素是数据的基本单位。在不同的条件下，数据元素又可称为 元素、结点、顶点、记录等。数据结构是指相互之间存在着一种或多种关系的数据元素的集合。 数据对象是性质相同的数据元素的集合。

4. 逻辑结构与存储结构是什么关系？

答：在数据结构中，逻辑结构与存储结构是密切相关的，存储结构不仅将数据元素存储到计算机 中，而且还要表示各数据元素之间的逻辑关系。逻辑结构与计算机无关，存储结构是数据元素之 间的关系在计算机中的表示。

5. 将数量级 210, n , n 2, n 3, nlog 2 n , log 2 n , 2n , n! , (2 / 3)n , 答：(2/3)n , 210, log2n , n2/3, n , nlog2n , n2, n3, 2n ,

6. 设有数据逻辑结构为：D={k1, k2, k3，…，k9} , R={, , , , , , 图示，并确定相对于关系 R,哪些结点是开始结点，哪些结点是终端结点？ 答：图略。开始结点k1、k2,终端结点k6、k7。

7. 设有如图1.1

D={k1, k2, k3，…，k8}, R={, , , , }，其逻辑结构类型为树型结构。 答：数据逻辑结构为： k4>, ,

{if( n==1)return(1) ;

⑵x=91

; y=100; While (y>0) if(x>10) y-- (3)i=1

; j=0 ； while(i+j v=n)

if(i>j)j++ ⑷ x=n ; y=0;

else return(n ~rec( n-1)) ; } else i++; while(x>=(y+1) ~(y+1)) y++ ; 答：(1) O(n)⑵ 0(1) (3) O(n)⑷ O(n 1/2) 9.设n 为正数。试确定下列各程序段中前面加记号 型语句的频度: (1)i=1 ; k=0;

while(i<=n-1) ⑵ k=0

;

for(i=1

for(j=i

{@k+=10

~i ； i++

；iv=n ； i++)

;j<=n : j++) @k++ ；

答：(1)n-1 (2)n+(n-1)+ ……+1= n(n+1)/2

n 2/3

按增长率进行排列。 n! k3>, , , }，画出这个逻辑结构的 所示的逻辑结构图，给出它的逻辑结构，并说出它是什么类型的逻辑结构。

第二节 线性表

一、选择题 1．线性结构中的一个结点代表一个 ( ) 。 ~A ?数据元素

B .数据项

C .数据

D .数据结构 2.线性表L=(a1 , a2,…，ai ，…，an),下列说法正确的是()。 A ．每个元素都有一个直接前驱和直接后继 素的排列顺序必须是由小到大或由大到小的 素都有一个且仅有一个直接前驱和直接后继 3．顺序表是线性表的 ( ) 。 A .链式存储结构 ~B.顺序存储结构C 4．对于顺序表，以下说法错误的是 ( ) 。 B ．线性表中至少要有一个元素 C ．表中诸元 D ． ~除第一个元素和最后一个元素外其余每个元 ．索引存储结构 D ．散列存储结构 ~A .顺序表是用一维数组实现的线性表，数组的下标可以看成是元素的绝对地址 B .顺序表的 所有存储结点按相应数据元素间的逻辑关系决定的次序依次排列 C ．顺序表的特点是：逻辑结构 中相邻的结点在存储结构中仍相邻 D ．顺序表的特点是：逻辑上相邻的元素，存储在物理位置也 相邻的单元中 5．对顺序表上的插入、删除算法的时间复杂度分析来说，通常以 ( ) 为标准操作。 A .条件判断 ~B.结点移动 C .算术表达式 D .赋值语句 6．对于顺序表的优缺点，以下说法错误的是 ( ) 。 A ．无需为表示结点间的逻辑关系而增加额外的存储空间 B ．可以方便地随机存取表中的任 一结点 ?插入和删除操作较方便 D .由于顺序表要求占用连续的空间，存储分配只能预 先进行(静态分配 ) 7．在含有 为( ) 。 A ．n 8．在含有 n 个结点的顺序存储的线性表中，在任一结点前插入一个结点所需移动结点的平均次数 ~B ．n/2 C ．(n-1)/2 D ．(n+1)/2 n 个结点的顺序存储的线性表中，删除一个结点所需移动结点的平均次数为 ( )

~C ． (n-1)/2 D ．(n+1)/2 A ．n B ．n/2

9.带头结点的单链表head 为空的条件是()。 A ．head=NULL ~B ． 10．非空单循环链表 A ．p->next=NULL

11 ．在双循环链表的 A ．p->next=s ；s->prior=p

；p->next->prior=s >next->prior=s ；s->prior=p ：s->next=p->next ； >next=s ；p->next->prior=s >next=s ； 12. 在一个单链表中，已知~q 结点是~p 结点的前驱结点，若在~q 和~p 之间插入结点~s ，则执行 ( ) 。 A ．s->next=p->next ；p->next=s ； B ．p->next=s->next ；s->next=p ； ~C ．q->next=s; s->next=p ； D ．p->next=s; s->next=q ； 13. 在一个单链表中，若-p 结点不是最后结点。在-p 之后插入结点~s ，则执行()。 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; 14. 若某线性表中最常用的操作是取第 i 个元素和找第 i 个元素的前驱元素，则采用 ( ) 存储 方式最节省时间。 ~A.顺序表 B. 单链表 C .双链表 D .单循环链表 15．设 rear 是指向非空带头结点的单循环链表的尾指针，则删除表头结点的操作可表示为 ( ) 。

head->next=NULL C ．head->next=head D ．head!=NULL head 的尾结点~p 满足()。 B ． p=NULL ~C ．p->next=head D ．p=head ~p 结点之后插入 ~s 结点的操作是 ( ) 。 ；s->next=p->next ； B ．p->next=s ； C ．s->prior=p ；s->next=p->next ； ~D ．s->prior=p ；s->next=p->next ；p->next->pror=s ； p- p- p-

A ．p=rear ；rear=rear->next ； free(p)

B ．rear=rear->next ；free(rear) ；

C ．rear=rear->next->next ； free(rear) ； ~

D ．p=rear->next->next ； rear->next- >next=p->next ；free(p) ； 16．在一个单链表中，若删除 ~p 结点的后继结点，则执行 ( ) 。

~A ．q=p->next ； p->next=q->next ； free(q) ； B ．p=p->next ；p->next=p->next->next ；

free(p) ； C ．p->next=p->next ；free(p->next) ； D ．p=p->next->next ； free(p->next) ； 17．设指针 p 指向双链表的某一结点，则双链表结构的对称性可用 ( ) 式来刻画。 A ．p->prior->next->==p->next->next B ．p->prior->prior==p->next->prior ~C ．p- >prior->next->==p->next->prior D ．p->next->next==p->prior->prior

18．在循环链表中，将头指针改设为尾指针 rear 后，其头结点和尾结点的存储位置分别是 ( ) 。 A . rear 和 rear->next->next ~B. rear->next 和 rear C . rear->next->next 和 rear D ．rear 和 rear->next 19．循环链表的主要优点是 ( ) 。

A ．不再需要头指针了

B ．已知某个结点的位置后，容易找到它的直接前驱

C ．在进行插 入、删除操

作时，能更好地保证链表不断开 ~D.从表中任一结点出发都能扫描到整个链表 20．在线性表的下列存储结构中，读取元素花费时间最少的是 A .单链表 B .双链表 C .循环链表 ~D.顺序表 二、 判断题 V1 .顺序存储的线性表可以随机存取。

X 2.顺序存储的线性表的插入和删除操作不需要付出很大的代价，因为平均每次操作只有近一半 的元素需要移动。

V3.线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此是属 于同一数据对象。

X 4.在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上不一定相邻。 V 5.在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。 V 6.在单链表中，可以从头结点开始查找任何一个元素。 X 7.线性表的链式存储结构优于顺序存储结构。

V 8.在线性表的顺序存储结构中，插入和删除元素时，移动元素的个数与该元素的位置有关。

X 9.在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存 储结构。

X10.顺序存储方式只能用于存储线性结构。 三、 填空题

1 .为了便于讨论，有时将含n(n>0)个结点的线性结构表示成(a1，a2，…，an)，其中每个ai 代 表一个—结点_。a1称为_第一个_结点，an 称为_最后一个_结点，i 称为ai 在线性表中的_位置 _。对任意一对相邻结点ai 、ai+1(1 < ivn) , ai 称为ai+1的直接_前驱ai+1称为ai 的直接_ 后继 __。

2. 线性结构的基本特征是：若至少含有一个结点，则除起始结点没有直接 __前驱_外，其他结点 有且仅有一个直接 __前驱_；除终端结点没有直接 __后继_外，其他结点有且仅有一个直接 _后继

所有结点按一对一的邻接关系构成的整体就是 __线性 __结构。 线性表的逻辑结构是 __线性 _结构，其所含结点的个数称为线性表的 ___长度_。

q=p->next ；p->next=q->next ；

6 .非空的单循环链表head 的尾结点(由指针p 所指)满足_ p->next= head ____________ 。 7. rear 是指向非空带头结点的单循环链表的尾指针，则删除起始结点的操作可表示为 __ P=rear- >next ； q=p->next ； p->next=q->next ； free(q) ； 。

8对于一个具有n 个结点的单链表，在P 所指结点后插入一个结点的时间复杂度为 _0(1)_，在 给定值为 x 的结点后插入新结点的时间复杂度为 __ O(n)__。

9.单链表表示法的基本思想是用 ___指针___表示结点间的逻辑关系。

10．在顺序表中插入或删除一个元素，平均需要移动 _一半 _元素，具体移动的元素个数与 __元素 的位置 _有关。

11. 在一个长度为n 的向量的第i(1 < i < n+1)个元素之前插入一个元素时，需向后移动 _ 3. 4.

5. 在单链表中，删除P 所指结点的直接后继的操作是 free(q) ; ___ -

n-

i+1__个元素。

12.在一个长度为n的向量中删除第i(1 < i < n)个元素时，需向前移动 _ n-i _个元素。

13．在双链表中，每个结点有两个指针域，一个指向___前驱__，另一个指向___后继___。

14.在一个带头结点的单循环链表中，P指向尾结点的直接前驱，贝U指向头结点的指针head可用

p 表示为head=__ p->next->next ；___。

15.设head指向单链表的表头，p指向单链表的表尾结点，则执行p->next=head后，该单链表构成__单循环链表___。

16.在单链表中，若P和s是两个指针，且满足p->next与s相同，则语句p->next=s->next的作用是_删除_s指向的结点。

17.设r指向单循环链表的最后一个结点，要在最后一个结点之后插入s所指的结点，需执行的三条语句是___s->next= r->next __；r->next=s ；r=s；

18.____________________________________________________________________ 在单链表中，指针P所指结点为最后一个结点的条件是_ P->next=NULL ______________________________ 。

19.在双循环链表中，若要在指p 所指结点前插入s 所指的结点，则需执行下列语句：s-

>next=p；s->prior=p->prior ；__ p->prior->next __=s；p->prior=s ；

20.在单链表中，若要在p 所指结点之前插入s 所指的结点，可进行下列操作：

s->next=___ p->next __ ；p->next=s ；temp=p->data ；

p->data=__ s->data ___ ；s->data=__ temp _ ；

四、应用题

1.描述以下三个概念的区别：头指针，头结点，首元结点(第一个元素结点)。答：首元结点是指链表中存储的线性表中的第一个数据元素的结点。为了操作方便，通常在链表的首元结点之前附设一个结点，称为头结点。头指针是指向链表中的第一个结点的指针。

2.何时选用顺序表，何时选用链表作为线性表的存储结构为宜？答：从空间上来看，当线性表的长度变化较大、难以估计其规模时，选用动态的链表作为存储结构比较合适，但链表除了需要设置数据域外，还要额外设置指针域，因此当线性表长度变化不大、易于事先确定规模时，为了节约存储空间，宜采用顺序存储结构。从时间上来看，若线性表的操作主要是查找，很少进行插入和删除操作时，应选用顺序表。对于频繁进行插入和删除操作的线性表，宜采用链表作为存储结构。

3.在顺序表中插入和删除一个结点需平均移动多少个结点？具体的移动次数取决于哪两个因素？答：平均移动表中大约一半的结点，插入操作平均移动n/2 个结点，删除操作平均移动( n-1)/2 个结点。具体移动的次数取决于表长和插入、删除的结点的位置。

4.为什么在单循环链表中设置尾指针比设置头指针更好？答：单循环链表中无论设置尾指针还是头指针都可以遍历表中任一个结点，但设置尾指针时，若

在表尾进行插入或删除操作可在0(1)时间内完成，同样在表头进行插入或删除操作也可在0(1)时间内完成。但若设置的是头指针，表尾进行插入或删除操作，需要遍历整个链表，时间复杂度为0(n)。

5.双链表和单循环链表中，若仅知道指针P指向某个结点，不知道头指针，能否将结点-p从相

应的链表中删除？若可以，其时间复杂度各为多少？

答：能删除。双链表上删除P所指向的结点的时间复杂度为0(1)，单循环链表上删除P所指向的结点的时间复杂度为0(n)。

6.下列算法的功能是什么？

LinkList testl(LinkList L)

{//L 是无头结点的单链表

ListNode ~q，~P；

if(L&&L->next)

{ q=L ；L=L->next

p=L;

while(P->next) P=P->next

p->next=q; q->next=NULL ；}

return L ；} 答： 如果长度大于 1，则将首元结点删除并插入到表尾。 7．如果有 n 个线性

表同时共存，并且在处理过程中各表的长度会发生动态变化，线性表的总长度 也会自动地改变。在此情况下，应选择哪一种存储结构？为什么？ 答：应选用链式存储结构。因为顺序表是静态存储结构，只能预先分配，不能随着线性表长度的 改变而变化。而链表则可根据需要动态地申请空间，因此适用于动态变化表长的线性表。 8．若线性表的总数基本稳定，且很少进行插入、删除操作，但要求以最快的方式存取线性表的元 素，应该用哪种存储结构？为什么？ 答：应选用顺序存储结构。因为顺序存储结构存取元素操作的时间复杂度为 五、算法设计题

O(1)。 1. 试用顺序表作为存储结构，实现将线性表(aO , a1, a2,…an-1)就地逆置的操作，所谓“就 地”是指辅助空间为 O(1)。 答：(1) 顺序表的就地逆置 分析：分别用两个整型变量指向顺序表的两端，同时向中间移动，移动的同时互换两个下标指示 的元素的值。 void Seqreverse(SeqList L){ ／／顺序表的就地逆置 for(i=O ；j=L.1ength-1 ；i

(2) 链表的就地逆置 分析：本算法的思想是逐个地把 L 的当前元素 r 插入到新的链表头部。

void Linkedreverse(LinkedList L){ ／／链表的就地逆置 p=L->next ；L->next=NULL ； while(p!=NULL)

{r=p ， p=p->next ； ／／r 指向当前待逆置的结点， p 记下下—个结点 r->next=L —>next ；L->next=r ； ／／放到表头 } } 2. 设顺序表L 是一个递增(允许有相同的值)有序表，试写一算法将x 插入L 中，并使L 仍为一个 有序

表。 答：分析：先找到x 的正确插入位置，然后将大于x 的元素从后向前依次向下移动，最后将 x 插 入到其位置上，同时顺序表长度增 1。 void SeqListinsert(SeqList L

， int x){ ／／x 插入到递增有序的顺序表 L 中 i=O; while((i<=L.length-1)&&(x>=L.data[i])) i++ for(k=L.length-1;k>=i L.data[k+1] L.data(i] L.1ength++ )

3. 设单链表L 疋 答：分析：此问题的关键是在链表中找到 移动。 void LinkListinsert(LinkedList L q=L ；p=q —>next ； while(p!=NULL&&p —>data

p=p —>next ； } s=(LinkedList)malloc(sizeof(LNode)) S —>data=x ； S —>next=p ； q 4. 试写出在不带头结点的单链表的第

／／找正确的插入位置 ；k--) ／／元素从后往前依次后移 ： L.data[k] ； x ； ／／x 插入到正确位置 个非递减有序表，试写一个算法将 x 插入其中后仍保持 L 的有序性。

x 的插入位置，因此需要两个指针一前一后地依次向后

，int x){ ／／x 插入有序链表 L 中 ／／找到插入的位置

； ／／生成新结点

—>next=s ； } i 个元素之前插入一个元素的算法。

if (i==m) for(t=j ; t

else for(t=i ; t

VOid Linkmerge(LinkedList A ， LinkedList B ， LinkedList C) {//有序链表A 和B 归并成有序链表C

pa=A —>next ； pb=B —>next ； C=A ； pc=C ； while(pa&&pb) // A 和B 都不为空时 {if( pa — >data< pb —>data) // A 当前结点值较小

{qa=pa->next ； pC->next=pa ； pc=pc->next ； pa=qa ； }

else {qb=pb->next ; pc->next=pb : pc=pc->next ; pb=qb ; } // B 当前结点值较小

}

if(pa)pc — >next=pa ; // A 没有结束，将A 表剩余元素链接到 if(pb)pc — >next=pb ; // B 没有结束，将B 表剩余元素链接到 free(B) ； //释放 B 表的头结点

}

本算法需要遍历两个线性表，因此时间复杂度为 O(m+n)。

6．设指针 la 和 lb 分别指向两个不带头结点的单链表的首结点，设计从表 起共 len 个元素，并将这些元素插入到 lb 中第 j 个结点之前的算法。 答：

分析：先在la 中找到第i 个结点，分别用两个指针pre 和p 指向第 用指针 q 从第 i 个结点起向后走 len 个元素，使 q 指向此位置。然后在 lb 中找到

第 j 个结点，将 p 所指向的 la 表中的第 i 个及 q 所指向的最后一个共 len 个结点插入到 lb 中。 void Deletelnsert(LinkedList la ， LinkedList lb ， int i ， int j, int len)

{//删除不带头结点的单链表 la 中第 i 个元素起共 len 个元素,并将这峰元素插入到单链表 lb 中第 j 个结点之前

if(i<0||j<0||len<0) exit(0) ； p=la ；k=1 ； pre=NULL ；

答：分析：对不带头结点的链表操作时，要注意对第一个结点和其他结点操作的不同。 void LinkedListlnsert(LinkedList { //不带头结点的单链表的第 p=L ： j=1;

while(p!=NULL&&jnext ； j++ ； } if(i<=0||p==NULL) printf(

head ，int x ， int i) i 个元素之前插入一个元素 ／／找到第 i-1 个元素 ”插入位置不正确、n ”);

； q —>data=x ； —>next=L ； L=q ； } //在第一个元素之前插入 //在其他位置插入 else {q=(LinkedList)malloc(sizeof(LNode)) if(i==1) {q else{q —>next=p —>next ；

p —>next=q ； }

} }

5.设A B 是两个线性表，其表中元素递增有序，长度分别为 m 和n 。试写一算法分别以顺序存储 和链式存储将A 和B 归并成一个仍按元素值递增有序的线性表 Co 答：(1)分析：用三个变量i 、j 、k 分别指示A 、B 、C 三个顺序表的当前位置，将 A B 表中较小 的元素写入C 中，直到有一个表先结束。最后将没结束的表的剩余元素写入 SeqList Seqmerge(SeqList A i=0 ； j=0 ； k=0； // i ，

while(i

{C.data[k]=A.data[il else {C.data[k]=B.data[j];j++

k++ ； } C 表中。 ，SeqList B){ //有序顺序表A 和B 归并成有序顺序表C i ，k 分别为顺序表A ，B, C 的下标 //A 中当前元素较小 ；i++ ； ] ;} //B 中当前元素较小

la 中删除第 i 个元素 i-1 和第 i 个结点，然后

while(p&&knext; k++ ； }

if(!p) exit(O) ； q=p ； k=l ； while(q&&knext ； //p 指向 la 表中第 i 个结点 k++ ；} //查找 la 表中第 i+len-1 个结点 if(!q) exit(O) ； if(pre==la)

la=q —>next ； else pre

—>next=q —>next ；

//将从 la 中删除的结点插入到 if(j==1) {q->next=lb else { r=lb;

k=1 while(r&&k

//i=1 的情况 //完成删除 lb 中 ； lb=p ； } // j=1 时 // j>1 时

—>next ; k++ ； } //查找Lb 表中第i — 1个元素 q —>next=r —>next ； r —>next=p ； //完成插入 } } 7.单链表L 是一个递减有序表，试写一高效算法，删除表中值大于 min 且小于max 的结点(若表

中有这样的结点)，同时释放被删结点空间，这里 min 和max 是两个给定的参数。 答： LinkedList delete(LinkedList L ， int min ， int max) { //删除递减有序单链表L 中值大于min 且小于max 的结点 q=L ；

if(min>max) {printf( else p=L —>next ； while(p —>data>=max) {q=p ； p=p —>next ； } while((p!=NULL)&&(p

一 { //当前元素的值比

q —>next=p —>next ， free(p) return L ；

} ． 8．编写一个算法将一个头结点指针为 为pa 和pb ，使得A 链表中含有原链表 偶数的元素，且保持原来

的相对顺序。 答：分析：用两个工作指针P 和q 分别指示序号为奇数和序号为偶数的结点，将 q 所指向的结点 从A 表删除，并链接到B 表。 void decompose(LinkedList A ， LinkedList B) {//单链表A 分解成元素序号为奇数的单链表A 和元素序号为偶数的单链表B

p=A->next ； B=(LinkedList)malloc(sizeof(LNode)) ； r=B ； while(p!=NULL&&p->next!=NULL) {q=p —>next ； p —>next=q —>next ； r — >next=q ； r=q ； //r p=p —>next ；

}

r —>next=NULL ； } 9.假设以两个元素依值递增有序排列的线性表 A B 分别表示两个集合，要求另辟空间构造一个 线性表C,其元素为两集合的交集，且表 C 中的元素也依值递增有序排列。对顺序表编写求 C 的算

法。 ” min>maX\ n ” )； exit(O) ; } // q 始终指向 p 的前驱 //当前元素大于或等于max 则P 、q 依次向后移动

>data>min)) min 大同时比max 小，删除p 指向的结点 ；p=q —>next ； } pa 的单链表A 分解成两个单链表A 和B,其头结点指针分别 A 中序号为奇数的元素，而B 链表中含有原链表A 中序号为 ／／q 指向偶数序号的结点 //将q 从A 表中删除 //将q 结点链接到B 链表的末尾 总是指向B 链表的最后一?个结点 //P 指向原链表A 中的奇数序号的结点 ／／将生成 B 链表中的最后一个结点的 next 域置为空

答：分析：用三个变量i 、j 、k 分别指示A 、B 、C 三个顺序表的当前位置，若 A B 表中当前元素 值相

同，贝U 写入C 中，并使i 、j 、k 值增1;若A 表元素值较小，则使i 增1;若B 表元素值较 小，则使 j 增 1，直到有一个表先结束。

SeqLiSt intersection(SeqList A ， SeqList B ， SeqList C) {//求元素依值递增有序排列的顺序表 A B 的交集C i=0 ; j=0 ; k=0;

while((i<=A.length-1)&&(j<=B.length-1)) {if(A.data[i]==B.data[j]) {C.data[k]=A.data[i] k++ ; i++ ; j++ ; else

if(A.data[i]

法，使得：C=(a1，b1，…，am ，

bm ，bm+1,…bn)(当 m< n 时)或(a1 ，b1，…，an ，bn ， an+1，…am)(当m>n 时)，线性表 A B C 均以单链表作为存储结构，且 C 表利用A 表和B 表的 结点空间。

答：分析：使P 和q 指向A 和B 表当前元素，并分别使nextp 和nextq 指向p 和q 的后继，这样 将q 所指向的结点链接到P 的后面，再把nextp 和nextq 的值赋给p 和q ，处理下一个结点。 void merge(LinkedList A ， LinkedList B ， LinkedList C)

{ //把链表A 和B 合并为C, A 和B 的元素间隔排列，且使用原存储空间 p=A —>next ; q=B —>next ; C=A ; while(p&&q)

{nextp=p — >next ; p —>next=q ; //将 B 的元素插入 if(nextp) {nextq=q->next ; q->next=nextp ; } //如果 A 非空，将 A 的元素插入 p=nextp ； q=nextq ； } }

11．假设在长度大于 1 的单循环链表中，既无头结点也无头指针。 s 为指向链表中某个结点的指 针，试编写算法删除结点 ~s 的直接前驱结点。

答：分析：因为既不知道此单循环链表的头指针，也不知道其尾指针，所以找 s 的前驱就只能从 s 开

始，顺次向后寻找。

void DeletePre(LinkedNode ~s)

{//删除单循环链表中结点 s 的直接前驱 p=s ；

while(p —>next —>next!=s) p=p —>next ； //找到 s 的前驱的前驱 p q=p — >next ; // q 是p 的后继，即s 的前驱 p — >next=s ； //将 q 删除 free(q) ； }

12．计算带头结点的循环链表的结点个数。 答： int number(LinkedNode head) { //计算单循环链表中结点的个数 p=head — >next ； i=0 ； while(p!=head) {i++ ；p=p->next ；} return i ； }

13．已知由单链表表示的线性表中，含有三类字符的数据元素 (如：字母字符、数字字符和其他字 符) ，试编写算法构造三个以循环链表表示的线性表，使得每个表中只含有同一类的字符，且利用 原表

中的结点空间作为这三个表的结点空间，头结点可另辟空间。

／／找到值相同的元素 //相同元素写入 C 表中 ;// A B 表当前元素不等，值较小的下标增1 }

am)和 B=(b1, b2,…，bn)。试编写合并A 、B 为线性表C 的算

答：分析： p 指向待处理的单链表的首元结点，构造三个空的单循环链表，分别存储三类字符，其 中一个可使用原来的单链表。q 指向P 的下一个结点，根据-p 的数据域的值将其插入到不同的链 表上。再把q 的值给P ，处理下一个结点。

void change(LinkedList L ， LinkedList pa ， LinkedList pb ， LinkedList pc)

{ //分解含有三类字符的单链表为三个以循环链表表示的线性表，使其分别含有三类字符 p=L —>next ; pa=L ;

pa —>next=pa ; //分别构造三个单循环链表 pb=(LinkedList)malloc(sizeof(LNode)) ; pc=(LinkedList)malloc(sizeof(LNode)) ; pb —>next=pb ; pc —>next=pc ;

while(p!=L)

{q=p if(p {p else {p else{p->next=pc->next p=q ; } }

14、己知A B 和C 为三个递增有序的线性表，现要求对 A 表进行如下操作：删去那些既在 B 表中 出现又在C 表中出现的元素。试对顺序表编写实现上述操作的算法 (注：题中未特别指明同一表中 的元素值各不相同 )。

答：分析：先从B 和C 中找出共有元素，记为same 再在A 中从当前位置开始，凡小于 same 的元 素均保

留(存到新的位置)，等于same 的就跳过，至U 大于same 时就再找下一个Same SeqList IntersectDelete(SeqList A ， SeqList B ， SeqList C) {//对顺序表A 删去那些既在B 表中出现又在C 表中出现的元素

i=0 ; j=0 ; k=0； m=0; // i 指示A 中元素原来的位置，m 为移动后的位置

while(i

else if(B.data[j]>C.data[k]) k++;

else {same=B.data[j] ； while(B.data[j]==same) j++ while(C.data[k]==same) k++ while(i

}

while(i

A.data[m++]=A.data[i++] A.1ength=m ； }

15．双循环链表中，设计满足下列条件的算法。

(1)在值为x 的结点之前插入值为y 的结点。(2)在值为x 的结点之后插入值为y 的结点。(3)删 除值为 x 的结点。

答：分析：在双循环链表中插入和删除结点要注意修改双向的指针。

typedef struct DLNode

{DataType data ； struct DLNode~prior ， ~next ；}DLNode ， ~DLinkedList ； void DLinsertl(DLinkedList L ， int x ， int y)

—>next ;? //q 记下L 中下一个结点的位置 —>data<='z '&&p —>data>='a ') //链接到字母链表的头部 —>next=pa —>next ; pa —>next=p ; }

if (p — >data<='9' &&(p —>data>='0') //链接到数字链表的头部 —>next=pb —>next ; pb —>next=p ; }

; pc->next=p ; }//链接到其他字母链表的头部 ／／找到了相同元素 same ;/j 、k 后移到新的元素 //A 的剩余元素重新存储

{ //在双循环链表中插入结点p=L->next；

while(p!=L&&p->data!=x) p=p->next ； ／／在链表中查找值为 x 的结点 if(P->data==x) ／／找到值为 x 的结点

{q=P->Prior ； ／／q 指向值为 x 的结点的前驱

s=(DLinkedList)malloc(sizeof(DLNode)) s->data=y s->next=P P->Prior=s else{Printf(

； p->next->prior=p->prior ；free(p) ； } exit(0) ；}

设有一个双循环链表，其中有一结点的指针为 P ,编写算法将P 与其右边的一个结点进行交

void DLchange(DLinkedList P)

／／将双循环链表中 P 指向的结点与其右边的一个结点进

行交换

q=p — >next ； // q 指向p 的后继 p — >prior — >next=q ; q —>pnor=p

— >prior ； //将 p 的前驱与 q 相链接

p — >next=q ——>next ； p ——>prior=q ； //将 p 插入至J q 之后 q->next —>prior=p ； q —>next=p ； }

17．设有一个双链表，每个结点中除有 prior 、data 和 next 三个域外，还有一个可访问颊度域 freq ,在链表启用之前，其值均初始为 0。每当链表进行一次LocateNode(L , x)操作时令元素值 为x 的结点中freq 域的值加I ，并调整表中结点的次序，使其按访问频度的递减次序排列，以便 使频繁访问的结点总是靠近表头。试写一符合上述要求的 LocateNode 操作的算法。

答：分析：先在双链表中查找值为 x 的结点，若找到则使其freq 值增1,然后从头至尾扫描链 表，将此结点插入至按 freq 递减顺序排列的正确位置。

typedef struct DLNode

{int data ， freq ； struct DLNode ~prior ， ~next ； }DLNode ， ~DLinkedList ； void LocateNode(DLinkedList head ， int x) {//双链表按访问频度域 freq 递减次序排列

p2=head ； p 仁p2 — >next ； // p2 在前，p1 在后 whue(p1) //查找单链表中值为x 的结点

if(pl — >data==x) {pl — >freq++ ； break ； }//使值为 x 的结点的 freq 力卩 1 else {p2=pl ； p1=p2—>next ； }

if(p 1==NULL) printf( ” Not found. \n ”)；

else{if(p1 —>next==NULL) {p2 —>next=p1 —>next ； temp=p1； } //在链表中找temp 所指向的结点，按freq 值递减应插入的位置 else{p2 —>next=p1 —>next ； //插入链表中间的某一位置 p1 —>next->prior=p2 ； temp=pl ； }

for(p2=head ， p1=p2->next ； pl&&p1->freq>temp->freq ； p2=p1， pl=p2->next) ；//插 入 if(p1==NULL) {p2->next=temp ； temp->prior=p2 ； temp->next=NULL ； }

else {p2->next=temp ； temp->prior=p2 ； temp->next=pl ； p1->prior=temp ； } } }

18．给出用单链表存储多项式的结构，并编写一个按指数值递增次序输入所产生的多项式链表的 过程。

s->Prior=q ；

／／将 y 插入到 q 与 P 指向的结点之

间

q->next=s ； }

没有值为x 的结点”)； exit(0) ；} }

void DLDelete(DLinkedList L {／／在双循环链表中删除结点

P=L->next ；

while(P!=L&&P->data!=x)P=P->next ；

if(P->data==x) {P->Prior->next=P->next else{printf( ”没有值为x 的结点”)； }

16． 换。 答： {

答： typedef struct PNode {int coef ; //系数 int exp ; //指数

struct Pnode ~next ; }~PLink ;

PLink CreatPoly( ) { //建立多项式

head=(PLink)malloc(sizeof(struct PNode)) ; r=head ;

printf( ”输入系数和指数：” ) ; scanf(&n ，&m); while(n!=0) //若 n=0 则退出循环

{s=(Plink)malloc(sizeof(struct PNode))

s->coef=n ; s->exp=m ; r->next=s

printf( ”输入系数和指数 : ”) ; r->next=NULL ; head=head —>next ;

return head ; }

19．根据上题的多项式链表结构，编写一个过程实现两个多项式相加的运算。 答：分析：对所有指数相同的项，将其对应系数相加，若和不为 0，则构造新“和多项式”的结

点;将所有指数不同的项复制到和多项式中。 Plink add(PLink pa ，PLink pb) { //多项式相加

p=pa ; q=pb ; pc=(PLink)malloc(sizeof(struct PNode))

while(p!=NULL&&q!=NULL)

;r=s ;//把s 链接到r 的后面 scanf （&n ， &m ）； } //删除头结点 ；r=pc ；

{if(p->exp==q->exp) //两结点的指数相同时，将两系数相加生成新结点插入 c 中 {x=p->coef+q->coef ;

if(x!=0){s=(PLink)malloc(sizeof(struct PNode))

r->next=s ; r=s ; } p=p->next ; q=q->next ; } else if(p->exp>q->exp) //两结点的指数不同时，将较小系数的结点复制成新结点插入 c 中 {s=(PLink)malloc(sizeof(struct PNode))

r->next=s ; r=s ; q=q->next ; }

else {s=(PLink)malloc(sizeof(struct PNode)) s->exp=p->exp ; r->next=s ; r=s ; p=p->next ;

}

while(p!=NULL) //复制A 的余下部分 {s=(PLink)malloc(sizeof(struct PNode)) r->next=s ：r=s ; p=p->next ; }

while(ql=NULL) //复制B 的余下部分

{s=(PLink)malloc(sizeof(struct PNode)) r->next=s ; r=s ; q=q->next ; }

; s->coef=x ; s->exp=p->exp ; ; s->coef=q->coef ; s->exp=q->exp ; ；s->coef=p->coef ； ; s->coef=p->coef ; s->exp=p->exp ; ; s->coef=q->coef ; s->exp=q->exp ; r->next=NULL ; //最后结点的 next 域置为空 s=pc ; pc=pc->next ; //删除 c 的头结点 free(s) ; return pc; }

20?约瑟夫环问题：任给正整数 n k ,按下述方法可得排列1, 2,…，n 的一个置换：将数字 l , 2,…，n 环形排列，按顺时针方向从1开始计数；计满k 时输出该位置上的数字(并从环中删 去该数字 )，然后从下一个数字开始继续计数，直到环中所有数字均被输出为止。例如， n=10、 k=3时，输出的置换是3, 6, 9, 2, 7, 1, 8, 5, 10。分别以数组和以不带头结点的、已知尾指 针的单

循环链表为存储结构解决上述问题。 答： void Js1(int A[n] , int N , iht K)

while(svK) {j=(j%N)+1 ; s=s+A[j-1] ; }

//计数

printf( ” %d , j); A[j-1]=0; //将计满k 值的数字输出，并将其位置标为

0表明已删除

} }

void Js2(LinkedList last , int N , int K)

{//以不带头结点的、已知尾指针的单循环链表为存储结构 P=last ; q=p->next ; //此时q 为头结点fp 为q 的前驱

while(N>0)

{for(j=2 ; j<=K ; j++) //循环 K-1 次

{p=q ; q=p->next ; }

printf( ” %d , q->data) ; N--; p->next=q->next; //删除 q

q=p — >next ; }

}

第三节栈和队列

一、选择题

1. 设有一顺序栈s ，元素s1, s2, s3, s4, s5, s6依次入栈，如果6个元素出栈的顺序是s2, s3, s4, s6, s5, s1,则栈的容量至少应该是（）。 A . 2 ~B. 3 C . 5 D . 6

2. 若一个栈的输入序列是a 、b 、c ,则通过入栈、出栈操作可能得到 （）。 A . 4

~B. 5 C . 6 D . 7

3. 设有一顺序栈已经含有3个元素，如图3-1所示，元素a4正等待入栈。以下序列中不可能出 现的出

栈序列是（）。

~A. a3, a1, a4, a2 B . a3, a2, a4, a1 C . a3, a4, a2, a1 D . a4, a3, a2, a1 口 niijiMZe I

- ------------------------- —

~

L

~A .因链栈本身没有容量限制，故在用户内存空间的范围内不会出现栈满情况

B .因顺序栈

本身没有容量限制，故在用户内存空间的范围内不会出现栈满情况 C .对于链栈而言，在栈满

{ //以数组为存储结构

for(i=0 j=0 for(i=0

{s=0

；ivN;i++)A[l]=1 ；i

//用1标志在环上的结点

a 、

b 、

c 的不同排列个数为

图3 1

4. 和顺序栈相比，链栈有一个比较明显的优势是 （）。

~A ?通常不会出现栈满的情况 D.删除操作更容易实现

5. 若一个栈的输入序列是1, 2, 是（）。 A .不确定 B . n-i ~C.

6. 以下说法正确的是（）。

B .通常不会出现栈空的情况

C .插入操作更容易实现

3, 4,…，n ,输出序列的第一个元素是n ,则第i 个输出元素

n-i+1 D . n-i-1

状态下,如果再进行入栈操作,则会发生“上溢” 再进行入栈操作,则会发生“下溢” 7．顺序队列的入队操作应为 ( ) 。

~A ．sq.rear=sq.rear+1 ；sq.data[sq.rear]=x; B sq.rear=sq.rear+1 ； C ． sq.rear=(sq.rear+1) D ．对于顺序栈而言，在栈满状态下，如果

D ．sq.data[sq.rear]=x ；sq.rear=x; sq.rear=(sq.rear+1) 8．循环队列的入队操作应为 ( ) 。 A ．sq ．rear=sq ．rear+1 ；sq ．data[sq ． sq ．rear=sq ． rear+l ； ~C ．sq ．rear=(sq D ．sq ． data[sq ． rear]=x ；

sq ．rear=(sq ． 9．顺序队列的出队操作为 ( ) 。 A ．sq ．front=(sq ．front+1) ％maxsize ；

C ．sq ．rear=(sq ．rear+1) ％maxsize ；

D ． 10．循环队列的出队操作为 ( ) 。 ~A ．sq ． front=(sq ．front+1) ％maxsize ； C ．sq ． re

ar=(sq ．rear+1) ％maxsize ； D 11．循环队列的队满条件为 ( ) 。

A ．(sq ．rear+1) ％maxsize==(sq ． maxsize==sq ．front+1 ；

~C ．(sq ． D ．sq ． rear==sq ．front ； 12．循环队列的

队空条件为 ( ) 。 A ．(sq ．rear+1) ％maxsize==(sq ． ．sq.data[sq.rear]=x ； ％maxsize ；sq.data[sq.rear+1]=x; ％ maxslze ； rear]=x B ． sq ．data[sq ． rear]=x ； ．rear+1) ％ maxsize ； sq ．data[sq ．rear]=x ； rear+1) ％maxsize ； ~B ．sq ．front=sq ． front+1 ； sq ．rear=sq ． rear+1; B ．sq ． front=sq ．front+1 ； ． sq ．rear=sq ．rear+l ； front+1) rear+1) front+1) ％maxsize ； B ．(sq ． rear+1) ％ maxsize==sq ．front ； ％maxsize ； B ．(sq ．rear+1) maxsize==sq ．front+1 ； C ．(sq ．rear+1) ％maxsize==sq ．front ； ~D ． sq ．rear==sq ．front ； 13．如果以链表作为栈的存储结构,则出栈操作时 ( ) 。 A .必须判别栈是否满 B .判别栈元素的类型 -C.必须判别栈是否空 D . 14, 向一个栈顶指针为Top 的链栈中插入一个s 所指结点时，其操作步骤为()。

对栈不做任何判别 A ．Top->next=s ； B ．s->next=Top->next ；Top->next=s ； ~C ． s->next=Top ；Top=s ； D ．s->next=Top ；Top=Top->next ； 15. 从栈顶指针为Top 的链栈中删除一个结点，并将被删结点的值保存到 x 中，其操作步骤为 ( ) 。 ~A ．x=Top->data ；Top=Top->next ； B ．Top=Top->next ；x=Top->data ； C ．x=Top ；

Top=Top->next ； D ．x=Top->data ； 16．在一个链队中,苕 f 、r 分别为队头、队尾指针

,则插入 s 所指结点的操作为 ( ) 。 A ．f->next=s ； f=s ； >next=f ；f=s ； 17．一个栈的入栈序列是 A ．e , d , c , b , a B

~B ．r->next=s ；r=s ； C ．s->next=r a , b , c , d , e ,则栈的不可能的输出序列是 ．d ， e ， c ， b ， a ~C ．d ， c ， e ， a ， b ；r=s ； D ．s- ( ) 。 D ． a , b , c , d , e ( ) 。 18．一个队列的入队序列是 1, 2, 3, 4,则队列的可能的输出序列是 A ． 4, 3, 2, 1 ~B ． 1 , 2, 3, 4 C ． 1 ,

4, 3, 2 D ． 3, 2, 4, 1 19．设计一个判别表达式中左,右括号是否配对出现的算法,采用 ( ) 数据结构最佳。 A .线性表的顺序存储结构

~B.栈 C .队列 D .线性表的链式存储结构 二、判断题

V1.在顺序栈栈满情况下，不能再入栈，否则会产生“上溢”。 X2.与顺序栈相比，链栈的一个优点是插入和删除操作更加方便。 X3.若一个栈的输入序列为1, 2, 3,…，n ,其输出序列的第一个元素为n ,贝U 其输出序列的每 个元素

ai 一定满足ai=i+1(i=1 , 2,…，n)。 V 4.在链队中，即使不设置尾指针也能进行入队操作。 V5.在对链队(带头指针)做出队操作时，不会改变front 指针的值。

9- 循环队列中元素个数为rear-fro nt 。

一个栈的输入序列是1,2,3,4，则在栈的输出序列中可以得到 4,3,1,2 . 一个栈的输入序列是

1,2,3,4，则在栈的输出序列中可以得到1,2,3,4。 若以链表作为栈的存储结构，则入栈需要判断栈是否满.

V10.若以链表作为栈的存储结构，则出栈需要判断栈是否空。

三、 填空题

1 .向一个栈顶指针为Top 的链栈中插入一个s 所指的结点时，其进行的操作是_ s->next=Top ; Top =s ; __。

2. 从栈顶指针为Top 的链栈中删除一个结点，并将结点保存在 x 中，进行的操作是_ x=Top- >data ; Top=Top->next ; __。

3. 在具有n 个单元的循环队列中，队满时共有 ___n-1_个元素。

4. 假设以S 和X 分别表示入栈和出栈操作，则对输入序列 a ，b ，c ，d ，e 进行一系列栈操作 SSXSXSSXX 之后，得至y 的输出序列为 _b , c ，e ，d ，a _。

5. 设有数组A[m]作为循环队列的存储空间，front 为队头指针，rear 为队尾指针，则元素x 执行 入队操作的语句是 _rear= (rear +1 )%( m+1 ； A[rear]=x; __。

6._____ 在一个链队中，如果f 、r 分别为队头、队尾指针，则插入 s 所指结点的操作是_r-> next=s; r=s; __ 。

7 ?栈的逻辑特点是—后进先出 ______ ，队列的逻辑特点是_先进先出__,二者的共同特点是_操作受 限_。

& ___栈—可以作为实现递归函数调用的一种数据结构。 9. 在队列中，新插入的结点只能添加到 __队尾_。 10. __________________________________ 链队在一定范围内不会出现 —队满 的情况。当lq . front==lq . rear 时，队中无元素，此 时___队空_。

11. 设一个链栈的栈顶指针为ls ，栈中结点的格式为data:next ，栈空的条件是_ ls = NULL __； 如果栈不为空，则出栈操作为 P=ls; ____ ls = ls ->next _ ； free(p)。 12. ____ 对带有头结点的链队lq ，判定队列中只有一个数据元素的条件是 __lq->front->next= lq- >rear 。 13. 设有一个空栈，现在输入序列为 1，2，3，4，5，经过Push ，push ，pop ，push ，pop ，push 后，栈顶指针所指元素是_4_。

14. 设用一维数组A[ln]来表示一个栈，令A[n]为栈底。用整型变量t 来指示当前栈顶的位置， A[t]为栈顶元素。往栈中压入一个新元素时，变量 量t 的值 ___ 减1 __ 。设空栈时，输入序列a ，b ，c 经过push ，pop ，push ，push ，pop 操作后， 从栈中弹出的元素是___c__o 四、 应用题 1. 试证明：若借助栈由输入序列1，2，3，…，n 得到输出序列p1，P2，…，pn(它是输入序列的 一个排列)，贝恠输出序列中不可能出现这样的情形：存在 ivj

2. 设有字符串为3~-y-a/yA2，试利用栈写出将其转换为3y- ~ay2^/-的操作过程。假定用x 代表 扫描该字符串过程中顺序取一个字符入栈的操作，用 s 代表从栈中取出一个字符加入到新字符串 尾的出栈操作。例如，ABC 变为BCA 的操作步骤为XXSXSS 答: XSXXXSSSXXSXXSXXSSSS

3. 设有一个输入序列a ，b ，c ，d ,元

素经过一个栈到达输出序列，而且元素一旦离开输入序列就 不能再回到输入序列，试问经过这个栈后可

以得到多少种输出序列 ？ 答：可以得到13种输出序列：

abcd,abdc,acbd,acdb,adcb,bacd,bcad,bcda,bdca,cbad,cbda,cdba,dcba.

4. 按照运算符优先法，画出对下面算术表达式求值时，操作数栈和运算符栈的变化过程：

X 6. X 7. V 8. X 9. t 的值—加1—，从栈中弹出一个元素时，变

2~4+(8+1)/3。

答：

序号

9-

5. 链栈中为何不设置头结点？

答：因为链栈只在链表头插入和删除结点，不可能在链表中间插入或删除结点，算法实现很简 单，所以一般不设置头结点。

第五节树

（树根结点的高度为1）

一、选择题

1 .以下说法错误的是（）。

~A.树形结构的特点是一个结点可以有多个直接前驱 个直接后继 C .二叉树与树是两种不同的数据结构 层次’结构 2. 以下说法错误的是（）。

A .二叉树可以是空集

B .二叉树的任一结点都有两棵子树 构D 、二叉树中任一结点的两棵子树有次序之分 3. 以下说法错误的是（）。

A .完全二叉树上结点之间的父子关系可由它们编号之间的关系来表达

B .在三叉链表上，二 叉树的求双亲操作很容易实现

C .在二叉链表上，求根以及求左、右孩子等操作很容易实现 ~D.在二叉链表上，求双亲操作的时间性能很好 4 .以下说法错误的是（）。

A . 一般在哈夫曼树中，权值越大的叶子离根结点越近

B .哈夫曼树中没有度数为1的分支结

点C .若初始森林中共有n 棵二叉树，最终求得的哈夫曼树共有 2n-1个结点 ~D.若初始森 林中共有n 棵二叉树，进行2n-1次合并后才能剩下一棵最终的哈夫曼树 5.深度为6的二叉树最多有（）个结点。 A . 64 ~B . 63 C . 32 D . 31

6 .将含有41个结点的完全二叉树从根结点开始编号，根为 1号，后面按从上到下、从左到右的 顺序对结点编号，那么编号为21的双亲结点编号为（）。

?线性结构中的一个结点至多只有一 .树（及一切树形结构）是一种“分支 ~c.二叉树与树具有相同的树形结