线性表 栈与队列 数据结构习题及答案.docx

线性表 栈与队列 数据结构习题及答案.docx

《线性表 栈与队列 数据结构习题及答案.docx》由会员分享，可在线阅读，更多相关《线性表 栈与队列 数据结构习题及答案.docx（21页珍藏版）》请在冰豆网上搜索。

线性表栈与队列数据结构习题及答案

第二章线性表

一、选择题

1．线性表是（A）。

A、一个有限序列，可以为空；B、一个有限序列，不能为空；

C、一个无限序列，可以为空；D、一个无序序列，不能为空。

2．对顺序存储的线性表，设其长度为n，在任何位置上插入或删除操作都是等概率的。

插入一个元素时平均要移动表中的（A）个元素。

A、n/2B、（n+1）/2C、（n-1）/2D、n

3．线性表采用链式存储时，其地址（D）。

A、必须是连续的B、部分地址必须是连续的C、一定是不连续的D、连续与否均可以

4．用链表表示线性表的优点是（C）。

A、便于随机存取B、花费的存储空间较顺序存储少

C、便于插入和删除D、数据元素的物理顺序与逻辑顺序相同

5、某链表中最常用的操作是在最后一个元素之后插入一个元素和删除最后一个元素，则采用（D）存储方式最节省运算时间。

A、单链表B、双链表C、单循环链表D、带头结点的双循环链表

6、循环链表的主要优点是（D）。

A、不在需要头指针了

B、已知某个结点的位置后，能够容易找到他的直接前趋

C、在进行插入、删除运算时，能更好的保证链表不断开

D、从表中的任意结点出发都能扫描到整个链表

7、下面关于线性表的叙述错误的是（B）。

A、线性表采用顺序存储，必须占用一片地址连续的单元；

B、线性表采用顺序存储，便于进行插入和删除操作；

C、线性表采用链式存储，不必占用一片地址连续的单元；

D、线性表采用链式存储，便于进行插入和删除操作；

8、单链表中，增加一个头结点的目的是为了（C）。

A、使单链表至少有一个结点B、标识表结点中首结点的位置

C、方便运算的实现D、说明单链表是线性表的链式存储

9、若某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用（D）存储方式最节省运算时间。

A、单链表B、仅有头指针的单循环链表C、双链表D、仅有尾指针的单循环链表

10、若某线性表中最常用的操作是取第i个元素和找第i个元素的前趋元素，则采用（B）存储方式最节省运算时间。

A、单链表B、顺序表C、双链表D、单循环链表

11、链表不具有的特点是（A）。

Ａ、可随机访问任一元素Ｂ、插入删除不需要移动元素

Ｃ、不必事先估计存储空间Ｄ、所需空间与线性表长度成正比

12、在一个有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂性为（B）。

A、O

（1） 　B、O（n）　C、O（n2）　D、O（log2n）

13、在一个单链表HL中，若要向表头插入一个自由指针p指向的结点，则执行（D）。

A、HL=p;p->next=HL;B、p->next=HL;HL=p;

C、p->next=HL;p=HL;D、p->next=HL->next;HL->next=p;

14、在一个单链表HL中，若要在指针q所指结点的后面插入一个自由指针p所指向的结　　点，则执行（D）。

A、q->next=p->next;p->next=q;B、p->next=q->next;q=p;

C、q->next=p->next;p->next=pD、p->next=q->next;q->next=p;

15、在一个单链表HL中，若要删除由指针q所指向结点的后继结点，则执行（D）。

A、p=q->next;p->next=q->next;B、p=q->next;q->next=p;

C、p=q->next;p->next=q;D、q->next=q->next->next;

16、给定有n个元素的向量，建立一个有序的单链表的时间复杂度为（C）。

A、O

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

17、不带头结点的单链表first为空的判定条件是（A）。

A、first==NULLB、first->next==NULLC、first->next==firstD、first!

=NULL

18、在非空的循环双链表中q所指的结点前插入一个由p所指结点的过程依次为：

p->next=q;p->prior=q->prior;q->prior=p;和（C）。

A、q->next=pＢ、q->prior->next=pＣ、p->prior->next=pＤ、p->next->prior=p

19、线性表的链式存储结构与顺序存储结构相比优点是（D）。

A、所有的操作算法实现简单B、便于随机存储

C、不便于插入与删除D、便于利用零散的存储空间

20、在双向链表存储结构中,删除P所指向的结点时须修改指针（A）。

A、P->next->prior=P->priorP->prior->next=P->next

B、P->next=P->next->nextP->next->prior=P

C、P->prior->next=PP->prior=P->prior->prior

D、P->prior=P->next->nextP->next=P->prior->prior

21、向一个有127个元素原顺序表中插入一个新元素并保存原来顺序不变，平均要移动（B）

个元素。

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

22、在一个长度为n的顺序存储的线性表中，向第i个元素（1≤i≤n+1）之前插入一个新元素时，需要从年向前依次移（B）个元素。

A、n-iB、n-i+1C、n-i-1D、i

二、填空题

1、带头结点的单链表H为空的条件是（H->next==NULL）。

2、非空单循环链表L中*p是尾结点的条件是（p->next==L）。

3、在一个单链表中p所指结点之后插入一个由指针f所指结点，应执行s->next=（p->next）;和p->next=（f）的操作。

4、在一个单链表中p所指结点之前插入一个由指针s所指结点，可执行以下操作：

s->next=（p->next）;

p->next=s;

t=p->data;

p->data=（s->dada）;

s->data=（t）;

5．在顺序表中做插入操作时首先检查（插入位置是否合理）。

6、顺序表、链表分别通过（存储的相对位置）、（指针）体现元素的逻辑关系。

7、线性链表中指针的作用是（表示逻辑关系）。

8、在顺序表中，插入或者删除一个元素，需要平均移动（一半）个元素，具体移动的元素个数与（插入与删除的位置有关）有关。

9、顺序表中逻辑上相邻的元素的物理位置（一定）紧邻。

单链表中逻辑上相邻的元素的物理位置（不一定）紧邻。

10、在单链表中，除了首元结点外，任一结点的存储位置由（前趋结点的指针域）指示。

11、有一个单链表（不同结点的data域可能相等），其头指针为head,编写一算法计算数据域为x的结点的个数，请填空。

intcount（LinkListhead,ElemTypex）

{Node*p;

intn=0;

（p=head->next）;

While（p!

=NULL）

{if（（p->data==x））

n++;

（p=p->next）;}

returnn;}

12、单链表的逆置，请填空

voidinsert（LikListL）

{Node*p,*q,*r;

p=head;

（q=p->next或q=head->next）;

while（q!

=NULL）

{r=q->next;

（q->next=p）;

p=q;

q=r;

}head->next=NULL;head=p;}

三、判断题

1、双循环链表中，任一结点的后继指针均指向其逻辑后继。

（F）

2、线性表的逻辑顺序与存储顺序总是一致的。

（F）

3、顺序存储的线性表可以按序号随机存取。

（T）

4、顺序表的插入和删除操作不需要付出很大的时间代价，因为每次操作平均只有近一半的元素需要移动。

（F）

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

（T）

6、在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。

（F）

7、在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。

（T）

8、线性表的链式存储结构优于顺序存储结构。

（F）

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

（T）

10、线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。

（T）

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

（F）

四、操作题

1、下面算法调用方式为unknown（rear）；说明该算法的功能，若输入数据为ABCDE回车，画出该算法所得到的存储结构。

voidunknown（LinkList&rear）{

LinkListhead，s；

DataTypech；

rear=head=（ListNode*）malloc（sizeof（ListNode））；

head->next=head；

printf（"输入数据以回车键结束！

\n"）；

while（（ch=getchar（））!

='\n'）{

s=（LNode*）malloc（sizeof（LNode））；

s->data=ch；

s->next=rear->next；

rear->next=s；

rear=rear->next；

}

rear->next=head->next；

free（head）；}

参考答案：

rear

2、下面算法调用方式为Unknown（root）；说明该算法的功能，若输入数据为AB#CD##EF####回车，画出该算法所得到的存储结构。

voidUnknown（BiTree&T）{

charch；

if（（ch=getchar（））=='#'）T=NULL；

else{T=（BiTree）malloc（sizeof（BiTNode））；T->data=ch；

Unknown（T->lchild）；Unknown（T->rchild）；}

}

参考答案:

root

3、已知线性链表元素为字符（‘A’，‘B’，‘C’，‘D’，‘E’，‘F’），说明下面算法的功能，并画出该算法处理后所得到的存储结构。

voidUnknown（LinkList&head）//head为链表的表头指针

{LinkListp，s；

p=head->next；

while（p->next）{

s=p->next；

if（s->data%2==1）p=p->next；

else{

p->next=s->next;

free（s）；

}

}//endofwhile}

参考答案:

将单链表中ASCII码为偶数的结点删除。

4、设单链表的结点的结构为ListNode=（data,link），阅读下面的函数，指出它所实现的功能是什么。

Intunknown（ListNode*Ha）

{

Intn=0;

ListNode*p=Ha->link;

While（p）

{

n++;

p=p->next;

}

Return（n）;

}

参考答案:

计算单链表的长度或计算单链表的结点的个数。

5、假定p1和p2是两个单链表的表头指针，用来表示两个集合，单键表中的结点包括值域

data和指向后继的结点的指针域link，试根据下面的算法指出算法的功能。

intSS（ListNode*p1,ListNode*p2）

{ListNoder;

while（p2!

=NULL）

{r=p1;

while（r!

=NULL）

{if（p2->data==r->data）break;

r=r->link;

}

if（r==NULL）return0;

P2=p2->link;

}

return1;}

参考答案:

判断P2单链表所代表的集合是否为P1单链表所代表的集合的子集，若是则返回1，否则返回0。

五、算法题

１、已知两个单向链表A=（a，b，．．．．．．，c）；B=（d，e，．．．．．．，f），设计算法

voidMergeList（LinkList&A，LinkListB），实现将两个链表合并为一个单向链表

A=（d，e，．．．．．，f，c，．．．．．，b，a），其中A，B为两个链表的表头指针，小写字母为表中元素。

voidmerger（LinkList*A,LinkListB）{}

参考答案:

voidMergrList（LIstList&A,LinkListB）

{for（R=B;R->next;R=R->next）;

P=A->next

while（P）

{S=P;P=P->next;

S->next=R->next;

R->next=S;

}

A=B;

}

２、假定在一个带头结点的单链表L中所有结点的值按递增顺序排列，试写下面的函数，功

能是删除表L跌所有的值大于等于min，同时小于等于max的结点。

单链表的结构定义如下：

voidrangeDelete（ListNode*L,ElemTypemin,ElemTypemax）{}

参考答案：

voidrangeDelete（ListNode*L,ElemTypemin,ElemTypemax）

{listNode*q=L,*p=L->next;

while（p!

=NULL）

{if（p->data>=min&&p->data<=max）

{q->next=p->next;free（p）;p=q->next;

}

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

3、线性顺序表及链表就地逆置算法.

intrevSqList（SqList*L）{}intrevLinkList（LinkListL）{}

参考答案:

intrevSqList（SqList*L）

{inti;

ElemTypetemp;

for（i=0;ilength/2;i++）

{temp=L->elem[i];

L->elem[i]=L->elem[L->length-1-i];

L->elem[L->length-1-i]=temp;}

returnOK;}

intrevLinkList（LinkListL）

{LinkListP,Q;

P=L->next;

if（L->next&&P->next）

{Q=P->next;

P->next=NULL;

while（Q）

{P=Q;

Q=Q->next;

P->next=L->next;

L->next=P;}

}returnOK;}

4、设A和B是两个单链表，其表中元素递增有序。

试写一算法将A和B归并成一个按元素值递增有序的单链表C，并要求辅助空间为O

（1）。

LinkListMergeList_L（LinkListLa,LinkListLb）{}

参考答案:

LinkListMergeList_L（LinkListLa,LinkListLb）

{LinkListLc,pa,pb,pc;

pa=La->next;

pb=Lb->next;

Lc=pc=La;

while（pa&&pb）

{if（pa->data<=pb->data）{pc->next=pa;pc=pa;pa=pa->next;}else

{pc->next=pb;pc=pb;pb=pb->next;}}

pc->next=pa?

pa:

pb;

free（Lb）;

returnLa;}

5、已知一个的链表A，表中元素为整数，设计算法把表中的所有的负整数排列在所有非负整数之后。

voidDivide（LinkList*A）{}

参考答案:

voidDivide（LinkList*A）

{P=A->next;q=A;

while（p）

{if（p->data>=0）

{q->next=p->next;

p->next=A->next;

A->next=p;

P=q->next;

}

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

}

}

第三章栈与队列

一、选择题

1、一个栈的输入序列为1，2，3，4，下面哪一个序列不可能是这个栈的输出序列（　C　）。

A、1，3，2，4B、2，3，4，1C、4，3，1，2D、3，4，2，1

2、将一个递归算法改为对应的非递归算法时，通常需要使用（A）。

A、栈B、队列C、循环队列D、优先队列

3、若用数组S[1..n]作为两个栈S1和S2的共同存储结构，对任何一个栈，只有当S全满时才不能作入栈操作。

为这两个栈分配空间的最佳方案是（C）。

A、S1的栈底位置为0，S2的栈底位置为n+1B、S1的栈底位置为0，S2的栈底位置为n/2

C、S1的栈底位置为1，S2的栈底位置为nD、S1的栈底位置为1，S2的栈底位置为n/2

4、在一个具有n个单元的顺序栈中，假设栈底是存储地址的低端，现在我们以top作为栈顶指针，则作退栈操作时，top的变化是（A）。

A、top=top-1　B、top=top+1　C、top不变 　D、top不确定

5、链栈和顺序栈相比较，有一个明显的特点是（A）。

A、链栈通常不会出现栈满的情况　B、链栈通常不会出现栈空的情况

C、链栈的插入操作更加方便　　　D、链栈的删除操作更加方便。

6、在一个链队中，假设f和r分别为队首和队尾指针，删除一个结点的运算是（C）。

A、r=f—>next　B、r=r—>next　C、f=f—>next D、f=r—>next

7、向一个栈顶指针为top的链栈中插入一个s所指结点时，其操作步骤是（B）。

A、top—>next=s　　　　　　　　B、s—>next=top;top=s;

C、s—>next=top—>next;top—>next=s;　

D、s—>next=top;top=top—>next

8、栈的插入与删除操作在（A）进行。

A、栈顶B、栈底C、任意位置D、指定位置

9、当利用大小为N的数组顺序存储一个队列时，该队列的最大长度为（B）。

A、N-2B、N-1C、ND、N+1

10、假定一个顺序队列的队首和队尾指针分别为f和r，则判断队空指针的条件为（D）。

A、f+1==rB、r+1==fC、f==0D、f==r

11、在系统实现递归调用时需利用递归工作记录保存（C），当递归调用结束时通过它将控

制转到上层调用程序。

A、调用地址B、递归入口C、返回地址D、递归出口

12、设栈的输入序列是1,2,3,4……n若输出序列的第一个元素是n,则第i个输出元素（B）。

A、不确定B、n-i+1C、iD、n-i

二、填空题

1、已知顺序存储的循环队列中，front，rear分别为队头、队尾指针，MAX为队列中存储单

元的最大个数，若当队列中仅有一个空闲单元时视为队满，则队满条件为（（rear+1）%MAX==front）；一般情况下，队列中元素个数可表示为（（rear-front+MAX）%MAX）。

2、已知元素入栈先后为ABCDE，若C为第一个出栈元素，则下一个出栈的元素可能是

（B、D、E）。

3、已知仅设尾指针的单循环链表rear（指针域为next）表示队列，链表前端为队头，则结

点*s入队的语句依次为（s->next=rear->next）；（rear->next=s）；rear=rear->next；

4、已知仅设尾指针rear的无头结点的单循环链表（指针域为next）表示栈，链表前端为

栈顶，则结点*new进栈的语句依次为（new->next=rear->next）；（rear->next=new）；

（rear=new）;

5、在对栈的操作中，其插入和删除都是在栈的（同一端）进行的，所以导致后进栈的元

素必定先被删除，也就是说，栈的修改是按照（后进先出）的原则进行的，所以栈又称为

（LIFO）表。

6、在队列的操作中，其插入和删除工作是在表的两端进行的，它允许在表的一端进行插入，

一端进行删除，则允许插入的一端称为（队尾），允许删除的一端称为（队首），

先进入队列的成员必定先离开队列，所以队列又称为（FIFO）表。

7、向一个栈顶找针为HS的链栈中插入一个S所指的结点时，则执行（S->next=HS;HS=S；）。

8、在顺序队列中，应该有队头和队尾两个指针来指示，队头指针和队尾指针的初值在队列

的初始化时均应该设置为（0），当对队列进行插入和删除的操作后，如果头指

针和尾指针相等时，队列为（空）。

9、向栈中压入元素的操作是（压栈）。

对栈进行出栈时的操作是（出栈）。

10、在具有n个存储单元的队列中，队满时队中共有（n-1）个元素。

11、假设有一个顺序栈A，其中元素a1,a2,a3,a4,a5,a6依次进栈，如果已知六个元素出栈

的顺序是a2,a3,a4,a6,a5,a1,则此栈容量至少应该为（3）。

12、线性表、栈和队列都是（线性结构）结构，可以在线性表的（任意）位置上插入和删除。

13、判断单链表是否对称，对称返回1，否则返回0，请填空。

intxyz（LinkListL）

{

Node*p,*q;

intn1,n,i,x;

Stacks;

P=L->next;

q=p;

n=0;

while（q!

=NULL）

{

n++;

q=q->next;

}

n1=（n/2）;

for（i=1;i<=n1;i++）

{

push（s,p->data）;

（p=p->next）;

}

if（（n%2!

=0））

p=p->next;

while（p!

=NULL）

{

pop（s,x）;

if（p->data!

=x）break;

（p=p->next）;

}

if（p==NULL或!

p）return1;

elsereturn0;

}

三、判断题

1、栈与队列都是限制存取点的表，只是它们的存取特征不一样。

（T）

2、在链队列中，即使不设置尾指针也能进行入队操作。

（T）

3、递归调用算法与相同的功能的非递归算法相比，主要问题在于重复计算太多，而且本

身需要分配额外的空间和传递数据